-- 生成日期: 2013-04-02 12:31:52

SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";
SET time_zone = "+00:00";

-- 数据库名: jsdoc_pakinguo
-- 
DROP DATABASE `jsdoc_pakinguo`;
CREATE DATABASE `jsdoc_pakinguo` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;
USE `jsdoc_pakinguo`;

-- --------------------------------------------------------

-- 表结构: pt_basic_cn
-- 
CREATE TABLE IF NOT EXISTS `pt_basic_cn` (
  `p_path` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_filename` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_index` varchar(3) COLLATE utf8_unicode_ci NOT NULL,
  `p_title` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_titletip` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_titledesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_arguments` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_argumentsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_attributes` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_attributesdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_methods` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_methodsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_return` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_returndesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_code` text COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`p_filename`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

-- 表数据: 
-- 
INSERT INTO `pt_basic_cn` VALUES 
('/api_doc/Cookbook/Basic', 'HTML中使用JavaScript', '002', 'HTML中使用JavaScript的三种常见方式', 'Basic > 使用JavaScript', '一、内联方式\r\n      在页面中使用<script>元素，并设定其type属性为\"text/javascript\"，然后按照下面的方式添加到html文档的<head>或<body>元素中：\r\n      <script type=\"text/javascript\">\r\n          alert(\"test\");\r\n      </script>\r\n二、外部加载\r\n      此方式使用方式与一所使用的是一样的，只不过其多设定一个src属性，如：\r\n      <script type=\"text/javascript\" src=\"index.js\"></script>\r\n\r\n      以上两种方式，当添加到<head>元素中时，会在文档完成排版和绘制前先执行<script>中代码的解释，从上至下，此过程页面其余的内容不会被加载或显示出来，直到解释完毕，浏览器才执行文档排版与绘制；若是添加在<body>结束标签</body>之前的话，则是先浏览器排版与绘制html文档后才执行JavaScript代码的解释，这样会让用户先看到页面的内容，再体验JavaScript带来的交互效果。后者成为延迟脚本。\r\n\r\n三、延迟加载\r\n      另一种延迟脚本的实现方式是通过JavaScript的DOM操作方式来加载指定的外部资源。其实现方式请参看“代码示例”。', '', 'null', '', 'null', '', 'null', '', '', 'function loadScript(url){\r\n	var el = document.createElement(\"script\");\r\n	el.setAttribute(\"type\", \"text/javascript\");\r\n	el.setAttribute(\"src\", url);\r\n	document.body.appendChild(el);\r\n}'),
('/api_doc/Cookbook/Basic', 'HTML中使用JavaScript_draft', '002', 'HTML中使用JavaScript的三种常见方式', 'Basic > 使用JavaScript', '一、内联方式\r\n      在页面中使用<script>元素，并设定其type属性为\"text/javascript\"，然后按照下面的方式添加到html文档的<head>或<body>元素中：\r\n      <script type=\"text/javascript\">\r\n          alert(\"test\");\r\n      </script>\r\n二、外部加载\r\n      此方式使用方式与一所使用的是一样的，只不过其多设定一个src属性，如：\r\n      <script type=\"text/javascript\" src=\"index.js\"></script>\r\n\r\n      以上两种方式，当添加到<head>元素中时，会在文档完成排版和绘制前先执行<script>中代码的解释，从上至下，此过程页面其余的内容不会被加载或显示出来，直到解释完毕，浏览器才执行文档排版与绘制；若是添加在<body>结束标签</body>之前的话，则是先浏览器排版与绘制html文档后才执行JavaScript代码的解释，这样会让用户先看到页面的内容，再体验JavaScript带来的交互效果。后者成为延迟脚本。\r\n\r\n三、延迟加载\r\n      另一种延迟脚本的实现方式是通过JavaScript的DOM操作方式来加载指定的外部资源。其实现方式请参看“代码示例”。', '', 'null', '', 'null', '', 'null', '', '', 'function loadScript(url){\r\n	var el = document.createElement(\"script\");\r\n	el.setAttribute(\"type\", \"text/javascript\");\r\n	el.setAttribute(\"src\", url);\r\n	document.body.appendChild(el);\r\n}'),
('/api_doc/Cookbook/Basic', 'Javascript 概述', '001', '概述', 'Basic > 概述2', '      JavaScript是一种基于对象和事件驱动并具有相对安全性的客户端脚本语言。同时也是一种广泛用于客户端Web开发的脚本语言，常用来给HTML网页添加动态功能，比如响应用户的各种操作。它最初由网景公司（Netscape）的Brendan Eich设计，是一种动态、弱类型、基于原型的语言，内置支持类。JavaScript是Sun公司的注册商标。Ecma国际以JavaScript为基础制定了ECMAScript标准。JavaScript也可以用于其他场合，如服务器端编程。完完整的JavaScript实现包含三个部分：ECMAScript，文档对象模型，浏览器对象模型。　\r\n      Netscape公司在最初将其脚本语言命名为LiveScript。在Netscape在与Sun合作之后将其改名为JavaScript。JavaScript最初受Java启发而开始设计的，目的之一就是“看上去像Java”，因此语法上有类似之处，一些名称和命名规范也借自Java。但JavaScript的主要设计原则源自Self和Scheme[3].JavaScript与Java名称上的近似，是当时网景为了营销考虑与Sun公司达成协议的结果。为了取得技术优势，微软推出了JScript来迎战JavaScript的脚本语言。为了互用性，Ecma国际（前身为欧洲计算机制造商协会）创建了ECMA-262标准（ECMAScript）。现在两者都属于ECMAScript的实现。尽管JavaScript作为给非程序人员的脚本语言，而非作为给程序人员的编程语言来推广和宣传，但是JavaScript具有非常丰富的特性。\r\n      到此文档生成为止，当前javascript的最新版本为1.9版。\r\n\r\n      JavaScript简介\r\n      JavaScript廷生于1995年。当时，它的主要目的是处理以前由服务器端语言（如Perl）负责的一些输入验证操怍。在JavaScript问世之前，必须把表单数据发送到限务器端才能确定用户是否没有填写某个必填域，是否输入了无效的值。Netscape Navigator希望通过JavaScript来解决这个问题：在人们普遍使用电话拔号上网的年代，能够在客户端完成一些基本的验证任务绝对是令人兴奋的。毕竟，拨号上网的速度之慢，导致了与服务器的每一次数据交换事实上都成了对人们耐心的一次考验。\r\n      自此以后，JavaScript逐渐成为市面上常见浏览器必备的一项特色功能。如今，JavaScript的用途早已不再局限于简单的数据验证，而是具备了与浏览器窗口及其内容等几乎所有方面交互的能力。今天的JavaScript已经成为一门功能全面的编程语言，能够处理复杂的计算和交互，拥有了闭包、匿名(lamda，拉姆达)函数，甚至元编程等特性。作为Web的一个重要组成部分，JavaScript的重要性是不言而喻的，就连手机浏览器，甚至那些专为残障人士设计的浏览器等非常规浏览器都支持它。当然，微软的例子更为典型。里然有自己的客户端脚本语言VBScript，但微软仍然在Internet Explorer的早期版本中加入了自己的JavaScript实现。\r\n      JavaScript从一个简单的输入验证器发展成为一门强大的编程语言，完全出乎人们的意料。应该说，它既是一门非常简单的语言，又是一门非常复杂的语言。说它简单，是因为学会使用它只需片刻功夫；而说它复杂，是因为要真正掌握它则需要数年时间。要想全面理解和掌握JavaScript，关键在于弄清楚它的本质、历史和局限性。\r\n\r\n      JavaScript简史\r\n      1992年前后，一家名为Nombas的公司（后来被Openwave收购）开发了一种嵌入式脚本语言，并将其命名为C-minus-minus（简称Cmm）。Cmm背后的设计思想很简单：要足够强大，可以取代宏；同时还要与C（以及C++）非常相似，以便开发人员能够迅速掌握它。这个脚本语言被打包到共享软件CEnvi中，许多开发人员就是通过该软件首次体验到了它的强大功能。最终，Nombas公司把Cmm改名为ScriptEase，而ScriptEase则成为了这家公司产品开发的主要驱动力。在Netscape Navigator受到人们狂热追捧之际，Nombas公司开发了能够嵌入到网页中的CEnvi版本。而这种嵌入CEnvi的早期试验性网贞被叫做Espresso Pages（浓咖啡版网页），它们是在万维网上首次使用脚本语言的标志。相信当初的Nombas公司不太可能意识到，他们这种在网页中嵌入脚本的想法会在很大程度上左右未来因特网的发展。\r\n      在Web日益流行的同时，人们对客户端脚本语苦的需求也越来越性烈。那个时候绝大多数因特网用户都使用速度仅为28.8Kb/s的“猫”（调制解调器）上网，但网页的大小和复杂性却不断增加。为完成简单的表单验证而频繁地与服务器交换数据只会加重用户的负担。想象以下：用户填写完一个表单，单击“提交”按钮，然后等待30秒钟，最终服务器返回消息说有一个必填字段没有填好……当时走在技术革新最前沿的Netscape公司，决定着手开发一种客户端语言，用来处理这种简单的验证。\r\n      当时就职于Netscape公司的布兰登，艾奇(Brendan Eich)，开始着手为计划于l995年2月发布的Netsc印e Navigator 2开发一种名为LiveScript的脚本语言——该语言将同时在浏览器矛口服务器中使用（它在服务器上的名字叫LiveWire）。为了赶在发布日期前完成LiveScript的开发，Netscape与Sun公司建立了一个开发联盟。在Netscape Navigator 2正式发布前夕，Netscape均了搭上媒体热炒Java的顺风车，临时把LiveScript改名为JavaScript。\r\n      由于JavaScript 1.0获得了巨大成功，Netscape随即在Netscape Navigator 3中又发布了JavaScript 1.1。Web虽然羽翼未丰，但用户关注度却屡创新高。在这样的背景下，Netscape把自己定位为市场领袖型公司。与此同时，微软决定向与Navigator竞争的自家产品Internet Explorer浏览器投入更多资源。Netscape Navigator 3发布后不久，微软就在其Intemet Explorer 3中加入了名为JScript的JavaScript实现（命名为JScrit是为了避开与Netscape有关的授权问题）。以现在的眼光来看，微软1996年8月为进入Web浏览器领域而实施的这个重大举措，是导致Netscape日后蒙羞的一个标志性事件。然而，这个重大举措同时也标志着JavaScript作为一门语言，其开发向前迈进了一大步。\r\n      第二年，ISO/IEC（International Organization for Standardization and International Electrotechnical Commission，国标标准化组织和国际电工委员会）也采用了ECMAScript作为标准（即ISO/IEC-16262）。自此以后，浏览器开发商就开始致力于将ECMAScript作为各自JavaScript实现的基础，也在不同程度上取得了成功。', '', 'null', '', 'null', '', 'null', '', '', ''),
('/api_doc/Cookbook/Basic', 'Javascript 概述_draft', '001', '概述', 'Basic > 概述2', '      JavaScript是一种基于对象和事件驱动并具有相对安全性的客户端脚本语言。同时也是一种广泛用于客户端Web开发的脚本语言，常用来给HTML网页添加动态功能，比如响应用户的各种操作。它最初由网景公司（Netscape）的Brendan Eich设计，是一种动态、弱类型、基于原型的语言，内置支持类。JavaScript是Sun公司的注册商标。Ecma国际以JavaScript为基础制定了ECMAScript标准。JavaScript也可以用于其他场合，如服务器端编程。完完整的JavaScript实现包含三个部分：ECMAScript，文档对象模型，浏览器对象模型。　\r\n      Netscape公司在最初将其脚本语言命名为LiveScript。在Netscape在与Sun合作之后将其改名为JavaScript。JavaScript最初受Java启发而开始设计的，目的之一就是“看上去像Java”，因此语法上有类似之处，一些名称和命名规范也借自Java。但JavaScript的主要设计原则源自Self和Scheme[3].JavaScript与Java名称上的近似，是当时网景为了营销考虑与Sun公司达成协议的结果。为了取得技术优势，微软推出了JScript来迎战JavaScript的脚本语言。为了互用性，Ecma国际（前身为欧洲计算机制造商协会）创建了ECMA-262标准（ECMAScript）。现在两者都属于ECMAScript的实现。尽管JavaScript作为给非程序人员的脚本语言，而非作为给程序人员的编程语言来推广和宣传，但是JavaScript具有非常丰富的特性。\r\n      到此文档生成为止，当前javascript的最新版本为1.9版。\r\n\r\n      JavaScript简介\r\n      JavaScript廷生于1995年。当时，它的主要目的是处理以前由服务器端语言（如Perl）负责的一些输入验证操怍。在JavaScript问世之前，必须把表单数据发送到限务器端才能确定用户是否没有填写某个必填域，是否输入了无效的值。Netscape Navigator希望通过JavaScript来解决这个问题：在人们普遍使用电话拔号上网的年代，能够在客户端完成一些基本的验证任务绝对是令人兴奋的。毕竟，拨号上网的速度之慢，导致了与服务器的每一次数据交换事实上都成了对人们耐心的一次考验。\r\n      自此以后，JavaScript逐渐成为市面上常见浏览器必备的一项特色功能。如今，JavaScript的用途早已不再局限于简单的数据验证，而是具备了与浏览器窗口及其内容等几乎所有方面交互的能力。今天的JavaScript已经成为一门功能全面的编程语言，能够处理复杂的计算和交互，拥有了闭包、匿名(lamda，拉姆达)函数，甚至元编程等特性。作为Web的一个重要组成部分，JavaScript的重要性是不言而喻的，就连手机浏览器，甚至那些专为残障人士设计的浏览器等非常规浏览器都支持它。当然，微软的例子更为典型。里然有自己的客户端脚本语言VBScript，但微软仍然在Internet Explorer的早期版本中加入了自己的JavaScript实现。\r\n      JavaScript从一个简单的输入验证器发展成为一门强大的编程语言，完全出乎人们的意料。应该说，它既是一门非常简单的语言，又是一门非常复杂的语言。说它简单，是因为学会使用它只需片刻功夫；而说它复杂，是因为要真正掌握它则需要数年时间。要想全面理解和掌握JavaScript，关键在于弄清楚它的本质、历史和局限性。\r\n\r\n      JavaScript简史\r\n      1992年前后，一家名为Nombas的公司（后来被Openwave收购）开发了一种嵌入式脚本语言，并将其命名为C-minus-minus（简称Cmm）。Cmm背后的设计思想很简单：要足够强大，可以取代宏；同时还要与C（以及C++）非常相似，以便开发人员能够迅速掌握它。这个脚本语言被打包到共享软件CEnvi中，许多开发人员就是通过该软件首次体验到了它的强大功能。最终，Nombas公司把Cmm改名为ScriptEase，而ScriptEase则成为了这家公司产品开发的主要驱动力。在Netscape Navigator受到人们狂热追捧之际，Nombas公司开发了能够嵌入到网页中的CEnvi版本。而这种嵌入CEnvi的早期试验性网贞被叫做Espresso Pages（浓咖啡版网页），它们是在万维网上首次使用脚本语言的标志。相信当初的Nombas公司不太可能意识到，他们这种在网页中嵌入脚本的想法会在很大程度上左右未来因特网的发展。\r\n      在Web日益流行的同时，人们对客户端脚本语苦的需求也越来越性烈。那个时候绝大多数因特网用户都使用速度仅为28.8Kb/s的“猫”（调制解调器）上网，但网页的大小和复杂性却不断增加。为完成简单的表单验证而频繁地与服务器交换数据只会加重用户的负担。想象以下：用户填写完一个表单，单击“提交”按钮，然后等待30秒钟，最终服务器返回消息说有一个必填字段没有填好……当时走在技术革新最前沿的Netscape公司，决定着手开发一种客户端语言，用来处理这种简单的验证。\r\n      当时就职于Netscape公司的布兰登，艾奇(Brendan Eich)，开始着手为计划于l995年2月发布的Netsc印e Navigator 2开发一种名为LiveScript的脚本语言——该语言将同时在浏览器矛口服务器中使用（它在服务器上的名字叫LiveWire）。为了赶在发布日期前完成LiveScript的开发，Netscape与Sun公司建立了一个开发联盟。在Netscape Navigator 2正式发布前夕，Netscape均了搭上媒体热炒Java的顺风车，临时把LiveScript改名为JavaScript。\r\n      由于JavaScript 1.0获得了巨大成功，Netscape随即在Netscape Navigator 3中又发布了JavaScript 1.1。Web虽然羽翼未丰，但用户关注度却屡创新高。在这样的背景下，Netscape把自己定位为市场领袖型公司。与此同时，微软决定向与Navigator竞争的自家产品Internet Explorer浏览器投入更多资源。Netscape Navigator 3发布后不久，微软就在其Intemet Explorer 3中加入了名为JScript的JavaScript实现（命名为JScrit是为了避开与Netscape有关的授权问题）。以现在的眼光来看，微软1996年8月为进入Web浏览器领域而实施的这个重大举措，是导致Netscape日后蒙羞的一个标志性事件。然而，这个重大举措同时也标志着JavaScript作为一门语言，其开发向前迈进了一大步。\r\n      第二年，ISO/IEC（International Organization for Standardization and International Electrotechnical Commission，国标标准化组织和国际电工委员会）也采用了ECMAScript作为标准（即ISO/IEC-16262）。自此以后，浏览器开发商就开始致力于将ECMAScript作为各自JavaScript实现的基础，也在不同程度上取得了成功。', '', 'null', '', 'null', '', 'null', '', '', ''),
('/api_doc/Cookbook/Basic', '词法语法', '003', '词法、语法结构', 'Basic > 词法语法', '1、区分大小写\r\n      JavaScript是区分大小写的语言：包括关键字、变量、函数名和所有的标识符。在HTML中，标签和属性名可以是大小写，而在JavaScript中必须是小写。\r\n\r\n2、标识符\r\n      所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以是按照下列格式规则组合起来的一或多个字符：\r\n      ● 第一个字符必须是一个字母、下划线（一）或一个美元符号($)；\r\n      ● 口其他字符可以是字母、下划线、美元符号或数字。\r\n      标识符中的字母也可以包含扩展的ASCII或Unicode字母字符（如入和正），但我们不推荐这样散。\r\n      按照惯例，ECMAScript标识符采用驼峰大小写格式，也就是第一个字母小写，剩下的每个有意\r\n义的单词的首字母大写，例如：\r\n      firstSecond\r\n      myCar\r\n      doSomethinglmportant\r\n      虽然没有谁强制要求必须采用这种格式，但为了与ECMAScript内置的函数和对象命名格式保持一致，可以将其当作一种最佳实践。\r\n      ※注意：不能把关键字、保留字、true、false和null用作标识符。\r\n\r\n3、关键字和保留字\r\n      JavaScript的关键字：\r\n      break        case     catch      continue   debugger\r\n      default      delete   do         else       false\r\n      finally      for      function   if         in\r\n      instanceof   new      null       return     switch\r\n      this         throw    true       try        typeof\r\n      var          void     while      with\r\n\r\n      JavaScript同样保留了一些关键字，这些关键字在当前的语言版本中并没有使用，但在未来版本中可能会用到。ECMAScript 5保留了这些关键字：\r\n      class   const   enum   export   extends   import   super\r\n\r\n      此外，下面这些关键字在普通的JavaScript代码中是合法的，但是在严格模式下是保留字：\r\n      implements   let       private      public    yield\r\n      interface    package   protected    static\r\n\r\n      严格模式同样对下面的标识符的使用做了严格限制，它们并不完全是保留字，但不能用做变量名、函数名或参数名：\r\n      arguments   eval\r\n\r\n      ECMAScript 3将Java的所有关键字都列为自己的保留字，尽管这些保留字在ECMAScript 5中放宽了限制，但如果你希望代码能在基于ECMAScript 3夹现的解释器上运行的话，应当避免使用这些关键字作为标识符：\r\n      abstract   boolean        byte      char         class\r\n      const      double         enum      export       extends\r\n      final      float          goto      implements   import\r\n      int        interface      long      native       package\r\n      private    protected      public    short        static\r\n      super      synchronized   throws    transient    volatile\r\n\r\n      JavaScript预定义了很多全局变量和函数，应当避免把它们的名字用做变量名和函数名：\r\n      arguments      Array      Boolean      Date      decodeURI\r\n      decodeURIComponent      encodeURI      encodeURIComponent      Error      eval\r\n      EvalError      Function      Infinity      isFinite      isNaN\r\n      JSON      Math      NaN      Number      Object\r\n      parseFloat      parselnt      RangeError      ReferenceError      RegExp\r\n      String      SyntaxError      TypeError      undefined      URIError\r\n\r\n4、注释\r\n      JavaScript支持两种格式的注释。在行尾“//”之后的文本都会被JavaScript当做注释忽略掉的。此外,“/*”和“*/”之间的文本也会当做注释，这种注释可以跨行书写，但不能有嵌套的注释。下面都是合法的JavaScript注释：\r\n      // 这里是单行注释\r\n      /* 这里是一段注释 */ // 这里是另一段注释\r\n      /*\r\n      *这又是一段注释\r\n      *这里的注释可以连写多行\r\n      */\r\n\r\n5、空格、换行符、格式控制符、Unicode转义\r\n      JavaScript会忽略程序中标识(token)间的空格。多数情况下，JavaScript同样会忽略换行符（2.5节提到了一种意外情形）。由于可以在代码中随意使用空格和换行，因此可以采用整齐、一致的缩进来形成统一的编码风格，从而提高代码的可读性。除了可以识别普通的空格符(u0020)，JavaScript还可以识别如下这些表示空格的字符：水平制表符(u0009)、垂直制表符(u000B)、换页符(u000C)、不中断空白(u00A0)、字节序标记(uFEFF)，以及&Unic0de中所有Zs类别的字符。JavaScript将如下字符识别为行结束符：换行符(u000A)，回车符(u000D)，行分隔符(u2028)，段分隔符(u2029)。回车符加换行符在一起被解析为一个单行结束符。Unic0de格式控制字符（Cf类），比如“从右至左书写标记”  (u200F)和“从左至右书写标记”  (u200E)，控制着文本的视觉显示，这对于一些非英语文本的正确显示来说是至关重要的，这些字符可以用在JavaScirpt的注释、字符串直接量和正则表达式直接虽中，但不能用在标识符（比如，变量名）中。但有个例外，零宽连接符(u200D)和零宽非连接符(uFEFF)是可以出现在标识符中的，但不能作为标识符的首字符。上文也提到了，字节序标记格式控制符(uFEFF)被当成了空格来对待。\r\n\r\n6、语句\r\n      ECMAScript中的语句以一个分号结尾；如果省略分号，则由解析器确定语句的结尾，如下例所示：\r\n      var sum = a + b   //即使没有分号也是有效的语句——不推荐\r\n      var diff = a - b  //有效的语句——推荐\r\n      虽然语句结尾的分号不是必需的，但我们建议任何时候都不要省略它。因为加上这个分号可以避免很多错误（例如不完整的输入），开发人员也可以放心地通过删除多余的空格米压缩ECMAScript代码（代码行结尾处没有分号会导致压缩错误）。另外，加上分号也会在某些情况下增进代码的性能，因为这样解析器就不必再花时间推测应该在哪里插入分号了。\r\n      可以使用C风格J语法把多条语句组合刊一个代码块中，即代码块以左花括号({)开头，以右花括号(})结尾：\r\n      if(test){\r\n            test = false;\r\n            alert(test);\r\n      }\r\n      虽然条件控制语句（如if语句）只在执行多条语句的情况下才要求使用代码块，但最佳实践是始终在控制语句中使用代码块一即使代码块中只有一条语句，例如：\r\n      if (test)\r\n            alert(test);    //有效但容易出错，不要使用\r\n\r\n      if(test){       //推荐使用\r\n            alert(test);\r\n      }\r\n      在控制语句中使用代码块可以让编码意图更加清晰，而且也能降低修改代码时出错的几率。\r\n\r\n\r\n\r\n', '', 'null', '', 'null', '', 'null', '', '', ''),
('/api_doc/Cookbook/Basic', '词法语法_draft', '003', '词法、语法结构', 'Basic > 词法语法', '1、区分大小写\r\n      JavaScript是区分大小写的语言：包括关键字、变量、函数名和所有的标识符。在HTML中，标签和属性名可以是大小写，而在JavaScript中必须是小写。\r\n\r\n2、标识符\r\n      所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以是按照下列格式规则组合起来的一或多个字符：\r\n      ● 第一个字符必须是一个字母、下划线（一）或一个美元符号($)；\r\n      ● 口其他字符可以是字母、下划线、美元符号或数字。\r\n      标识符中的字母也可以包含扩展的ASCII或Unicode字母字符（如入和正），但我们不推荐这样散。\r\n      按照惯例，ECMAScript标识符采用驼峰大小写格式，也就是第一个字母小写，剩下的每个有意\r\n义的单词的首字母大写，例如：\r\n      firstSecond\r\n      myCar\r\n      doSomethinglmportant\r\n      虽然没有谁强制要求必须采用这种格式，但为了与ECMAScript内置的函数和对象命名格式保持一致，可以将其当作一种最佳实践。\r\n      ※注意：不能把关键字、保留字、true、false和null用作标识符。\r\n\r\n3、关键字和保留字\r\n      JavaScript的关键字：\r\n      break        case     catch      continue   debugger\r\n      default      delete   do         else       false\r\n      finally      for      function   if         in\r\n      instanceof   new      null       return     switch\r\n      this         throw    true       try        typeof\r\n      var          void     while      with\r\n\r\n      JavaScript同样保留了一些关键字，这些关键字在当前的语言版本中并没有使用，但在未来版本中可能会用到。ECMAScript 5保留了这些关键字：\r\n      class   const   enum   export   extends   import   super\r\n\r\n      此外，下面这些关键字在普通的JavaScript代码中是合法的，但是在严格模式下是保留字：\r\n      implements   let       private      public    yield\r\n      interface    package   protected    static\r\n\r\n      严格模式同样对下面的标识符的使用做了严格限制，它们并不完全是保留字，但不能用做变量名、函数名或参数名：\r\n      arguments   eval\r\n\r\n      ECMAScript 3将Java的所有关键字都列为自己的保留字，尽管这些保留字在ECMAScript 5中放宽了限制，但如果你希望代码能在基于ECMAScript 3夹现的解释器上运行的话，应当避免使用这些关键字作为标识符：\r\n      abstract   boolean        byte      char         class\r\n      const      double         enum      export       extends\r\n      final      float          goto      implements   import\r\n      int        interface      long      native       package\r\n      private    protected      public    short        static\r\n      super      synchronized   throws    transient    volatile\r\n\r\n      JavaScript预定义了很多全局变量和函数，应当避免把它们的名字用做变量名和函数名：\r\n      arguments      Array      Boolean      Date      decodeURI\r\n      decodeURIComponent      encodeURI      encodeURIComponent      Error      eval\r\n      EvalError      Function      Infinity      isFinite      isNaN\r\n      JSON      Math      NaN      Number      Object\r\n      parseFloat      parselnt      RangeError      ReferenceError      RegExp\r\n      String      SyntaxError      TypeError      undefined      URIError\r\n\r\n4、注释\r\n      JavaScript支持两种格式的注释。在行尾“//”之后的文本都会被JavaScript当做注释忽略掉的。此外,“/*”和“*/”之间的文本也会当做注释，这种注释可以跨行书写，但不能有嵌套的注释。下面都是合法的JavaScript注释：\r\n      // 这里是单行注释\r\n      /* 这里是一段注释 */ // 这里是另一段注释\r\n      /*\r\n      *这又是一段注释\r\n      *这里的注释可以连写多行\r\n      */\r\n\r\n5、空格、换行符、格式控制符、Unicode转义\r\n      JavaScript会忽略程序中标识(token)间的空格。多数情况下，JavaScript同样会忽略换行符（2.5节提到了一种意外情形）。由于可以在代码中随意使用空格和换行，因此可以采用整齐、一致的缩进来形成统一的编码风格，从而提高代码的可读性。除了可以识别普通的空格符(u0020)，JavaScript还可以识别如下这些表示空格的字符：水平制表符(u0009)、垂直制表符(u000B)、换页符(u000C)、不中断空白(u00A0)、字节序标记(uFEFF)，以及&Unic0de中所有Zs类别的字符。JavaScript将如下字符识别为行结束符：换行符(u000A)，回车符(u000D)，行分隔符(u2028)，段分隔符(u2029)。回车符加换行符在一起被解析为一个单行结束符。Unic0de格式控制字符（Cf类），比如“从右至左书写标记”  (u200F)和“从左至右书写标记”  (u200E)，控制着文本的视觉显示，这对于一些非英语文本的正确显示来说是至关重要的，这些字符可以用在JavaScirpt的注释、字符串直接量和正则表达式直接虽中，但不能用在标识符（比如，变量名）中。但有个例外，零宽连接符(u200D)和零宽非连接符(uFEFF)是可以出现在标识符中的，但不能作为标识符的首字符。上文也提到了，字节序标记格式控制符(uFEFF)被当成了空格来对待。\r\n\r\n6、语句\r\n      ECMAScript中的语句以一个分号结尾；如果省略分号，则由解析器确定语句的结尾，如下例所示：\r\n      var sum = a + b   //即使没有分号也是有效的语句——不推荐\r\n      var diff = a - b  //有效的语句——推荐\r\n      虽然语句结尾的分号不是必需的，但我们建议任何时候都不要省略它。因为加上这个分号可以避免很多错误（例如不完整的输入），开发人员也可以放心地通过删除多余的空格米压缩ECMAScript代码（代码行结尾处没有分号会导致压缩错误）。另外，加上分号也会在某些情况下增进代码的性能，因为这样解析器就不必再花时间推测应该在哪里插入分号了。\r\n      可以使用C风格J语法把多条语句组合刊一个代码块中，即代码块以左花括号({)开头，以右花括号(})结尾：\r\n      if(test){\r\n            test = false;\r\n            alert(test);\r\n      }\r\n      虽然条件控制语句（如if语句）只在执行多条语句的情况下才要求使用代码块，但最佳实践是始终在控制语句中使用代码块一即使代码块中只有一条语句，例如：\r\n      if (test)\r\n            alert(test);    //有效但容易出错，不要使用\r\n\r\n      if(test){       //推荐使用\r\n            alert(test);\r\n      }\r\n      在控制语句中使用代码块可以让编码意图更加清晰，而且也能降低修改代码时出错的几率。\r\n\r\n\r\n\r\n', '', 'null', '', 'null', '', 'null', '', '', '');


-- 表结构: pt_client_cn
-- 
CREATE TABLE IF NOT EXISTS `pt_client_cn` (
  `p_path` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_filename` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_index` varchar(3) COLLATE utf8_unicode_ci NOT NULL,
  `p_title` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_titletip` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_titledesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_arguments` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_argumentsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_attributes` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_attributesdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_methods` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_methodsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_return` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_returndesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_code` text COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`p_filename`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;


-- 表结构: pt_code_cn
-- 
CREATE TABLE IF NOT EXISTS `pt_code_cn` (
  `p_path` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_filename` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_index` varchar(3) COLLATE utf8_unicode_ci NOT NULL,
  `p_title` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_titletip` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_titledesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_arguments` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_argumentsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_attributes` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_attributesdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_methods` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_methodsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_return` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_returndesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_code` text COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`p_filename`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;


-- 表结构: pt_core_cn
-- 
CREATE TABLE IF NOT EXISTS `pt_core_cn` (
  `p_path` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_filename` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_index` varchar(3) COLLATE utf8_unicode_ci NOT NULL,
  `p_title` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `p_titletip` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_titledesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_arguments` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_argumentsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_attributes` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_attributesdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_methods` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_methodsdesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_return` varchar(100) COLLATE utf8_unicode_ci NOT NULL,
  `p_returndesc` text COLLATE utf8_unicode_ci NOT NULL,
  `p_code` text COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`p_filename`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

-- 表数据: 
-- 
INSERT INTO `pt_core_cn` VALUES 
('/api_doc/Cookbook/Core', 'Arguments', '002', 'Arguments (函数的参数和其他属性)', 'Core > Object > Arguments', '    Arguments对象只定义在函数体中。从技术上讲，Arguments对象不是数组，但它拥有数值属性和length属性，数值属性可当做是数组元素，length属性则表示数组元素的个数。这些数组元素是传递给该方法的参数值。元素0是第一个参数，元素1是第二个参数，以此类推。所有作为参数传人的值都会成为Arguments对象的数组元素，即便在函数声明中没有指定参数名。\r\n    调用函数时，会为其创建一个Arguments对象，并自动初始化局部变量arguments，指代该Arguments对象。Arguments对象的主要用途是，用来判断有多少个参数传人函数，还可用来指代未命名的参数。然而，除了数组元素和length属性，还可通过callee属性来指代匿名函数自身。\r\n    大部分情况下，可以将Arguments对象想象成一个数组，并额外带有callee属性。但是，Arguments对象并不是Array的实例，Arguments.length属性也不具有Array.length属性的任何特殊行为，而且不能用来改变数组的大小。\r\n    在非严格模式下，Arguments对象具有一个很不寻常的特性。当函数带有命名的参数时，Arguments对象的数组元素与局部变量是等同的。Arguments对象和参数名为引用同一个值提供了两种途径。用参数名改变一个函数参数的值，会同时影响通过Arguments对象获取的值，反之，通过Arguments对象改变一个函数参数的值，也会影响通过参数名获取的值。', '', '', '属性', '{\"callee\":\"%E6%8C%87%E5%BD%93%E5%89%8D%E6%AD%A3%E5%9C%A8%E6%89%A7%E8%A1%8C%E7%9A%84%E5%87%BD%E6%95%B0\",\"length\":\"%E4%BC%A0%E9%80%92%E7%BB%99%E5%87%BD%E6%95%B0%E7%9A%84%E5%8F%82%E6%95%B0%E4%B8%AA%E6%95%B0%EF%BC%8C%E4%BB%A5%E5%8F%8AArguments%E5%AF%B9%E8%B1%A1%E4%B8%AD%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E4%B8%AA%E6%95%B0\"}', '', '[\"\"]', '', '', ''),
('/api_doc/Cookbook/Core', 'Arguments_draft', '002', 'Arguments (函数的参数和其他属性)', 'Core > Object > Arguments', '    Arguments对象只定义在函数体中。从技术上讲，Arguments对象不是数组，但它拥有数值属性和length属性，数值属性可当做是数组元素，length属性则表示数组元素的个数。这些数组元素是传递给该方法的参数值。元素0是第一个参数，元素1是第二个参数，以此类推。所有作为参数传人的值都会成为Arguments对象的数组元素，即便在函数声明中没有指定参数名。\r\n\r\n    调用函数时，会为其创建一个Arguments对象，并自动初始化局部变量arguments，指代该Arguments对象。Arguments对象的主要用途是，用来判断有多少个参数传人函数，还可用来指代未命名的参数。然而，除了数组元素和length属性，还可通过callee属性来指代匿名函数自身。\r\n    大部分情况下，可以将Arguments对象想象成一个数组，并额外带有callee属性。但是，Arguments对象并不是Array的实例，Arguments.length属性也不具有Array.length属性的任何特殊行为，而且不能用来改变数组的大小。\r\n    在非严格模式下，Arguments对象具有一个很不寻常的特性。当函数带有命名的参数时，Arguments对象的数组元素与局部变量是等同的。Arguments对象和参数名为引用同一个值提供了两种途径。用参数名改变一个函数参数的值，会同时影响通过Arguments对象获取的值，反之，通过Arguments对象改变一个函数参数的值，也会影响通过参数名获取的值。', '', '[\"\"]', '属性', '{\"callee\":\"%E6%8C%87%E5%BD%93%E5%89%8D%E6%AD%A3%E5%9C%A8%E6%89%A7%E8%A1%8C%E7%9A%84%E5%87%BD%E6%95%B0\",\"length\":\"%E4%BC%A0%E9%80%92%E7%BB%99%E5%87%BD%E6%95%B0%E7%9A%84%E5%8F%82%E6%95%B0%E4%B8%AA%E6%95%B0%EF%BC%8C%E4%BB%A5%E5%8F%8AArguments%E5%AF%B9%E8%B1%A1%E4%B8%AD%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E4%B8%AA%E6%95%B0\"}', '', '[\"\"]', '', '', ''),
('/api_doc/Cookbook/Core', 'Arguments.callee', '003', 'Arguments.callee', 'Core > Object > Arguments > callee', '    Arguments.callee指代当前正在执行的函数。通过它可以引用匿名函数自身。该属性只定义在函数体中。', '', 'null', '', 'null', '', 'null', '', '', '//在匿名函数内使用callee属性来引用匿名函数自身，以便实现递归\r\nvar factorial = function(x){\r\n    if(x < 2) return 1;\r\n    else return x*arguments.callee(x-l);\r\n}\r\nvar y = factorial(5); //返回20'),
('/api_doc/Cookbook/Core', 'Arguments.callee_draft', '003', 'Arguments.callee', 'Core > Object > Arguments > callee', '', '', 'null', '', 'null', '', 'null', '', '', ''),
('/api_doc/Cookbook/Core', 'Arguments.length', '004', 'Arguments.length', 'Core > Object > Arguments > length', '    传递给函数的参数个数。\r\n    Arguments对象的length属性表示传给当前函数的参数个数。该属性只定义在函数体中。注意该属性表示的是实际传人的参数个数，而不是声明的参数个数。声明的参数个数请参阅Function.length。同时要留意该属性没有任何Array.length属性的特殊行为。', '', 'null', '', 'null', '', 'null', '', '', '//使用Arguments对象来检查传人参数个数的正确性\r\nfunction check(args){\r\n    var actual=args.length;         //实际的参数个数\r\n    var expected=args.callee.length;//期待的参数个数\r\n    if (actual !=expected){         //如果不相等,则抛出异常\r\n        throw new Error(\"参数个数有误：期望值：\"+expected+\";实际值：\"+actual);\r\n    }\r\n}\r\n//演示如何使用check()方法的示例函数\r\nfunction f(x,y,z){\r\n    check(arguments); //检查参数个数的正确性\r\n    return x+y+z;  //正常执行该函数的剩余代码\r\n}'),
('/api_doc/Cookbook/Core', 'Arguments.length_draft', '004', 'Arguments.length', 'Core > Object > Arguments > length', '    传递给函数的参数个数。\r\n    Arguments对象的length属性表示传给当前函数的参数个数。该属性只定义在函数体中。注意该属性表示的是实际传人的参数个数，而不是声明的参数个数。声明的参数个数请参阅Function.length。同时要留意该属性没有任何Array.length属性的特殊行为。', '', '', '', '', '', '', '', '', '//使用Arguments对象来检查传人参数个数的正确性\r\nfunction check(args){\r\n    var actual=args.length;         //实际的参数个数\r\n    var expected=args.callee.length;//期待的参数个数\r\n    if (actual !=expected){         //如果不相等,则抛出异常\r\n        throw new Error(\"参数个数有误：期望值：\"+expected+\";实际值：\"+actual);\r\n    }\r\n}\r\n//演示如何使用check()方法的示例函数\r\nfunction f(x,y,z){\r\n    check(arguments); //检查参数个数的正确性\r\n    return x+y+z;  //正常执行该函数的剩余代码\r\n}'),
('/api_doc/Cookbook/Core', 'arguments[]', '001', 'arguments[] (函数参数数组)', 'Core > Object > Arguments', '    arguments[]数组只定义在函数体中。在函数体中，arguments指代该函数的Arguments对象。该对象拥有数值属性，可当做数组来用，含有传人到该函数的所有参数。arguments标识符本质上是一个局部变量，在每个函数中会自动声明并初始化该变量。arguments仅在函数体中时才指代Arguments对象，在全局代码中为undefined。', '', 'null', '', 'null', '', 'null', '', '', ''),
('/api_doc/Cookbook/Core', 'Array', '005', 'Array (对数组的内置支持)', 'Core > Object > Array', '    数组是Javascript的基本特性。\r\n    构造函数：\r\n        new Array()\r\n        new Array(size)\r\n        new Array(el0,el1,...,eln)', '参数 [size,[el0,el1,...,eln]]', '{\"size\":\"%E8%AE%BE%E5%AE%9A%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%E3%80%82%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E7%9A%84length%E5%B1%9E%E6%80%A7%E7%AD%89%E4%BA%8Esize%E3%80%82\",\"el0,el1,...,eln\":\"%E5%8F%82%E6%95%B0%E5%88%97%E8%A1%A8%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%98%AF%E4%B8%A4%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E4%BB%BB%E6%84%8F%E5%80%BC%E3%80%82%E5%BD%93Array%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E7%94%A8%E8%BF%99%E4%BA%9B%E5%8F%82%E6%95%B0%E8%B0%83%E7%94%A8%E6%97%B6%EF%BC%8C%E6%96%B0%E5%88%9B%E5%BB%BA%E7%9A%84%E6%95%B0%E7%BB%84%E5%AE%9E%E4%BE%8B%E4%BC%9A%E7%94%A8%E6%8C%87%E5%AE%9A%E7%9A%84%E5%8F%82%E6%95%B0%E5%80%BC%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%EF%BC%8C%E5%B9%B6%E5%B0%86length%E5%B1%9E%E6%80%A7%E8%AE%BE%E7%BD%AE%E4%B8%BA%E5%8F%82%E6%95%B0%E4%B8%AA%E6%95%B0%E3%80%82\"}', '属性', '{\"length\":\"%E4%B8%80%E4%B8%AA%E5%8F%AF%E8%AF%BB%2F%E5%86%99%E7%9A%84%E6%95%B4%E6%95%B0%EF%BC%8C%E7%94%A8%E6%9D%A5%E6%8C%87%E6%98%8E%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%E3%80%82%E5%BD%93%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%8D%E8%BF%9E%E7%BB%AD%E6%97%B6%EF%BC%8Clength%E7%AD%89%E4%BA%8E%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E7%9A%84%E5%BA%8F%E5%8F%B7%E5%8A%A0%E4%B8%80%E3%80%82%E6%94%B9%E5%8F%98length%E5%80%BC%E4%BC%9A%E8%A3%81%E5%87%8F%E6%88%96%E6%89%A9%E5%85%85%E6%95%B0%E7%BB%84%E3%80%82\"}', '方法', '{\"concat()\":\"%E6%8A%8A%E5%85%83%E7%B4%A0%E8%A1%94%E6%8E%A5%E5%88%B0%E6%95%B0%E7%BB%84%E4%B8%AD%E3%80%82\",\"every()\":\"%E6%B5%8B%E8%AF%95%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E6%98%AF%E5%90%A6%E5%AF%B9%E6%AF%8F%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E9%83%BD%E4%B8%BA%E7%9C%9F%E3%80%82\",\"filter()\":\"%E8%BF%94%E5%9B%9E%E6%BB%A1%E8%B6%B3%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"forEach()\":\"%E4%B8%BA%E6%95%B0%E7%BB%84%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E8%B0%83%E7%94%A8%E6%8C%87%E5%AE%9A%E5%87%BD%E6%95%B0%E3%80%82\",\"indexOf()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9F%A5%E6%89%BE%E5%8C%B9%E9%85%8D%E5%85%83%E7%B4%A0%E3%80%82\",\"join()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E7%9A%84%E6%89%80%E6%9C%89%E5%85%83%E7%B4%A0%E8%BD%AC%E5%8C%96%E4%B8%BA%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E5%B9%B6%E8%A1%94%E6%8E%A5%E8%B5%B7%E6%9D%A5%E3%80%82\",\"lastIndexOf()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E4%B8%AD%E5%8F%8D%E5%90%91%E6%9F%A5%E6%89%BE%E3%80%82\",\"map()\":\"%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AD%EF%BC%8C%E8%AE%A1%E7%AE%97%E5%87%BA%E6%96%B0%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"pop()\":\"%E7%A7%BB%E9%99%A4%E6%95%B0%E7%BB%84%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E3%80%82\",\"push()\":\"%E6%8A%8A%E5%85%83%E7%B4%A0%E6%B7%BB%E5%8A%A0%E5%88%B0%E6%95%B0%E7%BB%84%E5%B0%BE%E9%83%A8%E3%80%82\",\"reduce()\":\"%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AD%EF%BC%8C%E8%AE%A1%E7%AE%97%E5%87%BA%E4%B8%80%E4%B8%AA%E5%80%BC%E3%80%82\",\"reduceRight()\":\"%E4%BB%8E%E5%8F%B3%E5%88%B0%E5%B7%A6%E7%BC%A9%E5%87%8F%E6%95%B0%E7%BB%84%E3%80%82\",\"reverse()\":\"%E5%9C%A8%E5%8E%9F%E6%95%B0%E7%BB%84%E4%B8%AD%E7%82%B9%E5%88%B0%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E9%A1%BA%E5%BA%8F%E3%80%82\",\"shift()\":\"%E7%A7%BB%E9%99%A4%E6%95%B0%E7%BB%84%E7%9A%84%E7%AC%AC%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E3%80%82\",\"slice()\":\"%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E7%9A%84%E4%B8%80%E9%83%A8%E5%88%86%E3%80%82\",\"some()\":\"%E6%B5%8B%E8%AF%95%E6%98%AF%E5%90%A6%E8%87%B3%E5%B0%91%E6%9C%89%E4%B8%80%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E8%83%BD%E8%AE%A9%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E4%B8%BA%E7%9C%9F%E3%80%82\",\"sort()\":\"%E5%9C%A8%E5%8E%9F%E6%95%B0%E7%BB%84%E4%B8%AD%E5%AF%B9%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E8%BF%9B%E8%A1%8C%E6%8E%92%E5%BA%8F%E3%80%82\",\"splice()\":\"%E6%8F%92%E5%85%A5%E3%80%81%E5%88%A0%E9%99%A4%E6%88%96%E6%9B%BF%E6%8D%A2%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"toLocaleString()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E8%BD%AC%E5%8C%96%E4%B8%BA%E6%9C%AC%E5%9C%B0%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"toString()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E8%BD%AC%E5%8C%96%E4%B8%BA%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"unshift()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E5%A4%B4%E9%83%A8%E6%8F%92%E5%85%A5%E5%85%83%E7%B4%A0%E3%80%82\"}', '返回值', '新创建和初始化的数组。当不带参数调用Array()时，返回的数组为空，length属性为0。当用单个数值参数调用时，构造函数返回的数组带有指定个数的未定义元素。使用其他参数调用时，构造函数会使用指定的参数值初始化数组。当Array()构造函数不带new操作符，直接当做函数调用时，其表现行为与带有new操作符调用时是完全一样的。', ''),
('/api_doc/Cookbook/Core', 'Array_draft', '005', 'Array (对数组的内置支持)', 'Core > Object > Array', '数组是Javascript的基本特性。\r\n\r\n构造函数：\r\n    new Array()\r\n    new Array(size)\r\n    new Array(el0,el1,...,eln)', '参数', '{\"size\":\"%E8%AE%BE%E5%AE%9A%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%E3%80%82%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E7%9A%84length%E5%B1%9E%E6%80%A7%E7%AD%89%E4%BA%8Esize%E3%80%82\",\"el0,el1,...,eln\":\"%E5%8F%82%E6%95%B0%E5%88%97%E8%A1%A8%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%98%AF%E4%B8%A4%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E4%BB%BB%E6%84%8F%E5%80%BC%E3%80%82%E5%BD%93Array%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E7%94%A8%E8%BF%99%E4%BA%9B%E5%8F%82%E6%95%B0%E8%B0%83%E7%94%A8%E6%97%B6%EF%BC%8C%E6%96%B0%E5%88%9B%E5%BB%BA%E7%9A%84%E6%95%B0%E7%BB%84%E5%AE%9E%E4%BE%8B%E4%BC%9A%E7%94%A8%E6%8C%87%E5%AE%9A%E7%9A%84%E5%8F%82%E6%95%B0%E5%80%BC%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%EF%BC%8C%E5%B9%B6%E5%B0%86length%E5%B1%9E%E6%80%A7%E8%AE%BE%E7%BD%AE%E4%B8%BA%E5%8F%82%E6%95%B0%E4%B8%AA%E6%95%B0%E3%80%82\"}', '属性', '{\"length\":\"%E4%B8%80%E4%B8%AA%E5%8F%AF%E8%AF%BB%2F%E5%86%99%E7%9A%84%E6%95%B4%E6%95%B0%EF%BC%8C%E7%94%A8%E6%9D%A5%E6%8C%87%E6%98%8E%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%E3%80%82%E5%BD%93%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%8D%E8%BF%9E%E7%BB%AD%E6%97%B6%EF%BC%8Clength%E7%AD%89%E4%BA%8E%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E7%9A%84%E5%BA%8F%E5%8F%B7%E5%8A%A0%E4%B8%80%E3%80%82%E6%94%B9%E5%8F%98length%E5%80%BC%E4%BC%9A%E8%A3%81%E5%87%8F%E6%88%96%E6%89%A9%E5%85%85%E6%95%B0%E7%BB%84%E3%80%82\"}', '方法', '{\"concat()\":\"%E6%8A%8A%E5%85%83%E7%B4%A0%E8%A1%94%E6%8E%A5%E5%88%B0%E6%95%B0%E7%BB%84%E4%B8%AD%E3%80%82\",\"every()\":\"%E6%B5%8B%E8%AF%95%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E6%98%AF%E5%90%A6%E5%AF%B9%E6%AF%8F%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E9%83%BD%E4%B8%BA%E7%9C%9F%E3%80%82\",\"filter()\":\"%E8%BF%94%E5%9B%9E%E6%BB%A1%E8%B6%B3%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"forEach()\":\"%E4%B8%BA%E6%95%B0%E7%BB%84%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E8%B0%83%E7%94%A8%E6%8C%87%E5%AE%9A%E5%87%BD%E6%95%B0%E3%80%82\",\"indexOf()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9F%A5%E6%89%BE%E5%8C%B9%E9%85%8D%E5%85%83%E7%B4%A0%E3%80%82\",\"join()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E7%9A%84%E6%89%80%E6%9C%89%E5%85%83%E7%B4%A0%E8%BD%AC%E5%8C%96%E4%B8%BA%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E5%B9%B6%E8%A1%94%E6%8E%A5%E8%B5%B7%E6%9D%A5%E3%80%82\",\"lastIndexOf()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E4%B8%AD%E5%8F%8D%E5%90%91%E6%9F%A5%E6%89%BE%E3%80%82\",\"map()\":\"%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AD%EF%BC%8C%E8%AE%A1%E7%AE%97%E5%87%BA%E6%96%B0%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"pop()\":\"%E7%A7%BB%E9%99%A4%E6%95%B0%E7%BB%84%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E3%80%82\",\"push()\":\"%E6%8A%8A%E5%85%83%E7%B4%A0%E6%B7%BB%E5%8A%A0%E5%88%B0%E6%95%B0%E7%BB%84%E5%B0%BE%E9%83%A8%E3%80%82\",\"reduce()\":\"%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AD%EF%BC%8C%E8%AE%A1%E7%AE%97%E5%87%BA%E4%B8%80%E4%B8%AA%E5%80%BC%E3%80%82\",\"reduceRight()\":\"%E4%BB%8E%E5%8F%B3%E5%88%B0%E5%B7%A6%E7%BC%A9%E5%87%8F%E6%95%B0%E7%BB%84%E3%80%82\",\"reverse()\":\"%E5%9C%A8%E5%8E%9F%E6%95%B0%E7%BB%84%E4%B8%AD%E7%82%B9%E5%88%B0%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E9%A1%BA%E5%BA%8F%E3%80%82\",\"shift()\":\"%E7%A7%BB%E9%99%A4%E6%95%B0%E7%BB%84%E7%9A%84%E7%AC%AC%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E3%80%82\",\"slice()\":\"%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E7%9A%84%E4%B8%80%E9%83%A8%E5%88%86%E3%80%82\",\"some()\":\"%E6%B5%8B%E8%AF%95%E6%98%AF%E5%90%A6%E8%87%B3%E5%B0%91%E6%9C%89%E4%B8%80%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E8%83%BD%E8%AE%A9%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E4%B8%BA%E7%9C%9F%E3%80%82\",\"sort()\":\"%E5%9C%A8%E5%8E%9F%E6%95%B0%E7%BB%84%E4%B8%AD%E5%AF%B9%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E8%BF%9B%E8%A1%8C%E6%8E%92%E5%BA%8F%E3%80%82\",\"splice()\":\"%E6%8F%92%E5%85%A5%E3%80%81%E5%88%A0%E9%99%A4%E6%88%96%E6%9B%BF%E6%8D%A2%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82\",\"toLocaleString()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E8%BD%AC%E5%8C%96%E4%B8%BA%E6%9C%AC%E5%9C%B0%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"toString()\":\"%E5%B0%86%E6%95%B0%E7%BB%84%E8%BD%AC%E5%8C%96%E4%B8%BA%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"unshift()\":\"%E5%9C%A8%E6%95%B0%E7%BB%84%E5%A4%B4%E9%83%A8%E6%8F%92%E5%85%A5%E5%85%83%E7%B4%A0%E3%80%82\"}', '返回值', '新创建和初始化的数组。当不带参数调用Array()时，返回的数组为空，length属性为0。当用单个数值参数调用时，构造函数返回的数组带有指定个数的未定义元素。使用其他参数调用时，构造函数会使用指定的参数值初始化数组。当Array0构造函数不带new操作符，直接当做函数调用时，其表现行为与带有new操作符调用时是完全一样的。', ''),
('/api_doc/Cookbook/Core', 'Array.concat()', '007', 'Array.concat()', 'Core > Object > Array > concat', '    concat()会将参数衔接到array中得到一个新数组并返回。它不会修改array。如果传给concat()的某个参数本身是一个数组，则会将该数组的元素衔接到array中，而不是数组本身。', '参数 array.contact(value[,...])', '{\"value,...\":\"%E4%BB%BB%E6%84%8F%E4%B8%AA%E8%A6%81%E8%A1%94%E6%8E%A5%E5%88%B0array%E4%B8%AD%E7%9A%84%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '一个新数组，包含array的元素以及衔接的新元素。', 'var a = [1,2,3];\r\na.concat(4,5);              // 返回 [1,2,3,4,5]\r\na.concat([4,5]);            // 返回 [1,2,3,4,5]\r\na.concat([4,5],[6,7]);    // 返回 [1,2,3,4,5,6,7]\r\na.concat(4,[5,[6,7]]);    // 返回 [1,2,3,4,5.[6,7]]'),
('/api_doc/Cookbook/Core', 'Array.concat()_draft', '007', 'Array.concat()', 'Core > Object > Array > concat', '    concat()会将参数衔接到array中得到一个新数组并返回。它不会修改array。如果传给concat()的某个参数本身是一个数组，则会将该数组的元素衔接到array中，而不是数组本身。', '参数 array.contact(value,...)', '{\"value,...\":\"%E4%BB%BB%E6%84%8F%E4%B8%AA%E8%A6%81%E8%A1%94%E6%8E%A5%E5%88%B0array%E4%B8%AD%E7%9A%84%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '一个新数组，包含array的元素以及衔接的新元素。', 'var a = [1,2,3];\r\na.concat(4,5);              // 返回 [1,2,3,4,5]\r\na.concat([4,5]);            // 返回 [1,2,3,4,5]\r\na.concat([4,5],[6,7]);    // 返回 [1,2,3,4,5,6,7]\r\na.concat(4,[5,[6,7]]);    // 返回 [1,2,3,4,5.[6,7]]'),
('/api_doc/Cookbook/Core', 'Array.every()', '008', 'Array.every()', 'Core > Object > Array > every', '    every()方法用来测试数组的所有元素是否都满足某些条件。它会按照序号从小到大的顺序遍历array的元素，并对每个元素调用指定的predicate函数。如果predicate返回false（或任何可以转化为false的值），则every()会停止遍历，并立刻返回false。如果predicate的每一次调用都返回true，则every()返回true。当遍历的数组为空时，every()返回true。\r\n\r\n    对数组的每一个序号i，调用predicate时带有三个参数：\r\n        predicate(array[i],i,array)\r\n\r\n    predicate的返回值会当做布尔值解析。true和所有真值表示该数组元素通过了测试或者说满足该函数所描述的条件。如果返回值为false或假值，则表示数组元素没有通过测试。\r\n\r\n    数组方法的细节：\r\n    下述细节适用于forEach()方法，也适用于相关方法：map()、filter()、every()和some0。所有这些方法都接受函数作为第一个参数，并接受可选的第二个参数。如果指定了第二个参数o，则调用函数时，就好像该函数是o的方法一样。也就是说，在函数体内，this值等于o。如果没有指定第二个参数，则就像函数一样调用该函数（而不像方法），this值在非严格模式下是全局对象，在严格模式下则为null。\r\n    所有这些方法都会在开始遍历时就记录array的长度。如果调用函数把新元素追加到array中，这些新添加的元素不会遍历到。如果调用的函数修改了未遍历到的已存在元素，则调用时会传递修改后的值。\r\n    当作用于稀疏数组时，这些方法不会在实际上不存在元素的序号上调用函数。', '参数 array.every(predicate[,o])', '{\"predicate\":\"%E7%94%A8%E6%9D%A5%E6%B5%8B%E8%AF%95%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8predicate%E6%97%B6%E5%8F%AF%E9%80%89%E7%9A%84this%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '如果对array的每一个元素调用predicate时都返回真值，则返回true。如果有任何一个元素调用predicate时返回假值，则返回false。', '[1,2,3].every(function(x){return x<5;))  // =>true:所有元素都<5\r\n[1,2,3].every(function(x){return x<3;))  // =>false:不是所有元素都<3\r\n[].every(function(x){return false;));    // =>true:[]总是返回true'),
('/api_doc/Cookbook/Core', 'Array.every()_draft', '008', 'Array.every()', 'Core > Object > Array > every', '    every()方法用来测试数组的所有元素是否都满足某些条件。它会按照序号从小到大的顺序遍历array的元素，并对每个元素调用指定的predicate函数。如果predicate返回false（或任何可以转化为false的值），则every()会停止遍历，并立刻返回false。如果predicate的每一次调用都返回true，则every()返回true。当遍历的数组为空时，every()返回true。\r\n\r\n    对数组的每一个序号i，调用predicate时带有三个参数：\r\n        predicate(array[i],i,array)\r\n\r\n    predicate的返回值会当做布尔值解析。true和所有真值表示该数组元素通过了测试或者说满足该函数所描述的条件。如果返回值为false或假值，则表示数组元素没有通过测试。', '参数 array.every(predicate,o)', '{\"predicate\":\"%E7%94%A8%E6%9D%A5%E6%B5%8B%E8%AF%95%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8predicate%E6%97%B6%E5%8F%AF%E9%80%89%E7%9A%84this%E5%80%BC%E3%80%82\"}', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Array.filter()', '009', 'Array.filter()', 'Core > Object > Array > filter', '    filter()会创建一个新数组，包含那些让predicate函数返回真值的array的元素。filter()方法不会修改array本身（注意predicate函数有可能会修改）。\r\n    filter()按照序号从小到大遍历array，对每个元素仅调用一次predicate，对于序号i，调用predicate时带有三个参数：\r\npredicate(array[i],i,array)\r\n    如果predicate返回真值，则array中序号为珀勺元素会追加到新创建的数组中。一旦filter()测试完array中的每一个元素，它就会返回新创建的数组。\r\n\r\n    数组方法的细节：\r\n    下述细节适用于forEach()方法，也适用于相关方法：map()、filter()、every()和some0。所有这些方法都接受函数作为第一个参数，并接受可选的第二个参数。如果指定了第二个参数o，则调用函数时，就好像该函数是o的方法一样。也就是说，在函数体内，this值等于o。如果没有指定第二个参数，则就像函数一样调用该函数（而不像方法），this值在非严格模式下是全局对象，在严格模式下则为null。\r\n    所有这些方法都会在开始遍历时就记录array的长度。如果调用函数把新元素追加到array中，这些新添加的元素不会遍历到。如果调用的函数修改了未遍历到的已存在元素，则调用时会传递修改后的值。\r\n    当作用于稀疏数组时，这些方法不会在实际上不存在元素的序号上调用函数。', '参数 array.filter(predicate[,o])', '{\"predicate\":\"%E7%94%A8%E6%9D%A5%E5%88%A4%E6%96%ADarray%E4%B8%AD%E7%9A%84%E5%85%83%E7%B4%A0%E6%98%AF%E5%90%A6%E9%9C%80%E8%A6%81%E5%8C%85%E5%90%AB%E5%9C%A8%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E8%B0%83%E7%94%A8%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8predicate%E6%97%B6%E7%9A%84%E5%8F%AF%E9%80%89this%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '一个新数组，只包含那些让predicate返回真值的数组元素。', '[1,2,3].filter(function(x) { return x > 1; }); // => [2,3]'),
('/api_doc/Cookbook/Core', 'Array.forEach()', '010', 'Array.forEach()', 'Core > Object > Array > forEach', '    forEach()按照序号从小到大遍历array，并对每一个元素调用一次f。对于序号i，调用f时带有三个参数：\r\n        f(array[i], i, array)\r\n    f的任何返回值都会忽略。注意forEach()没有返回值。特别注意，它不会返回array。\r\n\r\n    数组方法的细节：\r\n    下述细节适用于forEach()方法，也适用于相关方法：map()、filter()、every()和some0。所有这些方法都接受函数作为第一个参数，并接受可选的第二个参数。如果指定了第二个参数o，则调用函数时，就好像该函数是o的方法一样。也就是说，在函数体内，this值等于o。如果没有指定第二个参数，则就像函数一样调用该函数（而不像方法），this值在非严格模式下是全局对象，在严格模式下则为null。\r\n    所有这些方法都会在开始遍历时就记录array的长度。如果调用函数把新元素追加到array中，这些新添加的元素不会遍历到。如果调用的函数修改了未遍历到的已存在元素，则调用时会传递修改后的值。\r\n    当作用于稀疏数组时，这些方法不会在实际上不存在元素的序号上调用函数。', '参数 array.forEach(f[,o])', '{\"f\":\"%E4%B8%BAarray%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E8%B0%83%E7%94%A8%E7%9A%84%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8f%E6%97%B6%E7%9A%84%E5%8F%AF%E9%80%89this%E5%80%BC%E3%80%82\"}', '', '', '', '', '', '', 'var a = [1,2,3];\r\na.forEach(function(x,i,a) { a[i]++; }); // a is now [2,3,4]'),
('/api_doc/Cookbook/Core', 'Array.forEach()_draft', '010', 'Array.forEach()', 'Core > Object > Array > forEach', '    forEach()按照序号从小到大遍历array，并对每一个元素调用一次f。对于序号i，调用f时带有三个参数：\r\n        f(array[i], i, array)\r\n    f的任何返回值都会忽略。注意forEach()没有返回值。特别注意，它不会返回array。\r\n\r\n    数组方法的细节：\r\n    下述细节适用于forEach()方法，也适用于相关方法：map()、filter()、every()和some0。所有这些方法都接受函数作为第一个参数，并接受可选的第二个参数。如果指定了第二个参数o，则调用函数时，就好像该函数是o的方法一样。也就是说，在函数体内，this值等于o。如果没有指定第二个参数，则就像函数一样调用该函数（而不像方法），this值在非严格模式下是全局对象，在严格模式下则为null。\r\n    所有这些方法都会在开始遍历时就记录array的长度。如果调用函数把新元素追加到array中，这些新添加的元素不会遍历到。如果调用的函数修改了未遍历到的已存在元素，则调用时会传递修改后的值。\r\n    当作用于稀疏数组时，这些方法不会在实际上不存在元素的序号上调用函数。', '参数 array.forEach(f[,o])', '{\"f\":\"%E4%B8%BAarray%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E8%B0%83%E7%94%A8%E7%9A%84%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8f%E6%97%B6%E7%9A%84%E5%8F%AF%E9%80%89this%E5%80%BC%E3%80%82\"}', '', '', '', '', '', '', 'var a = [1,2,3];\r\na.forEach(function(x,i,a) { a[i]++; }); // a is now [2,3,4]'),
('/api_doc/Cookbook/Core', 'Array.indexOf()', '011', 'Array.indexOf()', 'Core > Object > Array > indexOf', '    该方法在array中查找等于value的元素，并返回找到的第一个元素的序号。查找的起始位置是start指定的数组序号，如果没有指定，则从0开始，然后一个接一个地查找，直到找到匹配的元素或检查完所有元素为止。判断是否相等使用的是“===”操作符。返回值是找到的第一个匹配元素的序号，如果没找到匹配的，则返回-1。', '参数 array.indexOf(value[,start])', '', '', '', '', '', '返回值', '一个大于等于start的最小序号值，该序号值处的array元素与value全等。如果不存在匹配元素时，则返回-1。', '[\"a\",\"b\",\"c\"].indexOf(\"b\")    // => 1\r\n[\"a\",\"b\",\"c\"].indexOf(\"d\")    // => -1\r\n[\"a\",\"b\",\'c\'].indexOf(\"a\",1)  // => -1'),
('/api_doc/Cookbook/Core', 'Array.join()', '012', 'Array.join()', 'Core > Object > Array >join', '    join()将数组的每一个元素转换为字符串，并通过在中间插入指定的separator字符串将它们衔接起来，最后返回衔接好的字符串。\r\n    可以进行相反的操作——将字符串分割成数组元素——使用String对象的split()方法即可。', '参数array.join([separator])', '{\"separator\":\"%E5%9C%A8%E8%BF%94%E5%9B%9E%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%EF%BC%8C%E7%94%A8%E6%9D%A5%E5%88%86%E9%9A%94%E6%95%B0%E7%BB%84%E7%9A%84%E6%9F%90%E4%B8%AA%E5%85%83%E7%B4%A0%E4%B8%8E%E4%B8%8B%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E7%9A%84%E5%8F%AF%E9%80%89%E5%AD%97%E7%AC%A6%E6%88%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82%E5%A6%82%E6%9E%9C%E7%9C%81%E7%95%A5%EF%BC%8C%E9%BB%98%E8%AE%A4%E6%98%AF%E8%8B%B1%E6%96%87%E9%80%97%E5%8F%B7%28%2C%29%E3%80%82\"}', '', '', '', '', '返回值', '一个字符串。将array的每一个元素转化为字符串，然后用separator字符串分隔开，最后衔接为返回的字符串。', 'a = new Array(1, 2, 3, \"testing\");\r\ns = a.join(\"+\"); // s is the string \"1+2+3+testing\"'),
('/api_doc/Cookbook/Core', 'Array.lastIndexOf()', '013', 'Array.lastIndexOf()', 'Core > Object > Array > lastIndexOf', '    该方法在array中一个接一个地反向查找等于value的元素，并返回找到的第一个元素的序号。查找的起始位置是start指定的数组序号，如果没有指定，则从最后一个元素开始。判断是否相等使用的是“===”操作符。返回值是找到的第一个匹配元素的序号，如果没找到匹配的，则返回-1。', '参数 array.lastIndexOf(value[, start])', '{\"value\":\"%E8%A6%81%E5%9C%A8array%E4%B8%AD%E6%9F%A5%E6%89%BE%E7%9A%84%E5%80%BC%E3%80%82\",\"start\":\"%E5%BC%80%E5%A7%8B%E6%9F%A5%E6%89%BE%E7%9A%84%E5%8F%AF%E9%80%89%E6%95%B0%E7%BB%84%E5%BA%8F%E5%8F%B7%E3%80%82%E5%A6%82%E6%9E%9C%E7%9C%81%E7%95%A5%EF%BC%8C%E5%88%99%E4%BB%8E%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E5%BC%80%E5%A7%8B%E6%9F%A5%E6%89%BE%E3%80%82\"}', '', '', '', '', '返回值', '一个小于等于start的最大序号值，该序号值处的array元素与value全等。如果不存在匹配元素时，则返回-1。', ''),
('/api_doc/Cookbook/Core', 'Array.length', '006', 'Array.length', 'Core > Object > Array > length', '    数组的length属性总是比该数组中定义的序号最大的元素的序号大一。一般来说，数组都是“稠密”数组，拥有连续的元素，并且序号从O开始。对于这种数组，length属性表示数组中的元素个数。\r\n    使用Array()构造函数创建数组时，会初始化该数组的length属性。把新元素添加到数组中，在有必要时，会更新length属性：\r\n        a = new Array();        //a.length初始化为0\r\n        b = new Array(10);    //b.length初始化为10\r\n        c = new Array(\"one\", \"two\"，\"three\");    //c.length初始化为3\r\n        c[3] = \"four\";             //c.length更新为4\r\n        c[10] = \"blastoff\";      //c.length变成11\r\n    可以设置length属性的值来改变数组的大小。如果设置的length小于原值，会裁减数组，末尾处的元素会丢失。如果设置的length大于原值，数组会变大，新添加到末尾处的元素的值为undefined。', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Array.length_draft', '006', 'Array.length', 'Core > Object > Array > length', '    数组的length属性总是比该数组中定义的序号最大的元素的序号大一。一般来说，数组都是“稠密”数组，拥有连续的元素，并且序号从O开始。对于这种数组，length属性表示数组中的元素个数。\r\n    使用Array()构造函数创建数组时，会初始化该数组的length属性。把新元素添加到数组中，在有必要时，会更新length属性：\r\n    a = new Array();        //a.length初始化为0\r\n    b = new Array(10);    //b.length初始化为10\r\n    c = new Array(\"one\", \"two\"，\"three\");    //c.length初始化为3\r\n    c[3] = \"four\";             //c.length更新为4\r\n    c[10] = \"blastoff\";      //c.length变成11', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Array.map()', '014', 'Array.map()', 'Core > Object > Array > map', '    map()会创建一个新数组，数组长度与array一样，数组元素通过将array的元素传递给函数f计算得到。map()按照从小到大的顺序遍历array的序号，并为每一个元素调用f一次。对于序号i，调用f时带有三个参数，f的返回值则存储在新创建数组的序号i处：\r\n        a[i]=f(array[i]，i,array)\r\n    一旦map()将array中的每一个元素都传递给f，并将其返回值存储在新数组中后，就会返回该新数组。', '参数 array.map(f[,o])', '{\"f\":\"%E4%B8%BAarray%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E8%B0%83%E7%94%A8%E7%9A%84%E5%87%BD%E6%95%B0%E3%80%82%E5%AE%83%E7%9A%84%E8%BF%94%E5%9B%9E%E5%80%BC%E4%BC%9A%E6%88%90%E4%B8%BA%E8%BF%94%E5%9B%9E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%83%E7%B4%A0%E3%80%82\",\"o\":\"f%E8%B0%83%E7%94%A8%E6%97%B6%E7%9A%84%E5%8F%AF%E9%80%89this%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '一个新数组，由函数f计算出的元素组成。', '[1,2,3].map(function(x) { return x*x; }); // => [1,4,9]'),
('/api_doc/Cookbook/Core', 'Array.pop()', '015', 'Array.pop()', 'Core > Object > Array > pop', '    pop()会移除array的最后一个元素，缩短数组的长度，并返回所移除元素的值。如果数组已经为空，pop()不会修改该数组，返回值是undefined。', '', '', '', '', '', '', '返回值', 'array的最后一个元素。', 'var stack = []; // stack: []\r\nstack.push(1, 2); // stack: [1,2] Returns 2\r\nstack.pop(); // stack: [1] Returns 2\r\nstack.push([4,5]); // stack: [1,[4,5]] Returns 2\r\nstack.pop() // stack: [1] Returns [4,5]\r\nstack.pop(); // stack: [] Returns 1'),
('/api_doc/Cookbook/Core', 'Array.push()', '016', 'Array.push()', 'Core > Object > Array > push', '    push()会将参数按顺序追加到array尾部。它会直接修改array，而不会创新一个新数组。push()与伴随的pop()方法，可以提供先进后出(FILO)的栈功能。例子请参考Array.pop()。', '参数 array.push(value[,....])', '{\"value,....\":\"%E8%BF%BD%E5%8A%A0%E5%88%B0array%E5%B0%BE%E9%83%A8%E7%9A%84%E4%B8%80%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '把指定值追加到数组后数组的新长度。', ''),
('/api_doc/Cookbook/Core', 'Array.reduce()', '017', 'Array.reduce()', 'Core > Object > Array > reduce', '    reduce()方法接受函数f为第一个参数。该函数的行为应该像一个二元操作符一样：接受两个值，执行某些操作，然后返回结果。如果array有n个元素，reduce()方法会调用n-1次来将这些元素缩减为一个合并值。（你可能已经熟悉了数组缩减操作，在其他编程语言中，有时称为“折叠”或“注入”。）\r\n    第一次调用f时传人的是array的前两个元素。接下来的调用会传人之前的计算值和array的下一个元素（按照从小到大的序号顺序）。最后一次调用f的返回值会成为reduce()方法的返回值。\r\n    reduce()在调用时可以传人可选的第二个参数：initial。如果指定initial, reduce()的行为会像是把该参数插入array的头部一样（注意，实际上并没有修改array）。换一种说法是，就像reduce()带有两个参数调用，而initial就像是之前f的返回值一样。这种情况下，第一次调用f时传人的是initial以和array的第一个元素。当指定initial时，要缩减的元素有n+1个（array的n个元素，加上initial值），则调用n次f。\r\n    如果array为空，又没有指定initi以，reduce()舍抛出TypeError异常。如果array为空，但指定initial，则reduce()返回initial以，且永远不调用f。如果array只有一个元素，且没有指定initial，reduce()不调用，，会返回array的单个元素。\r\n    上面的段落描述了舶两个参数，实际上reduce()调用柙寸传人了4个参数。第三个参数是第二个参数的数组序号。第4个参数则是array自身。f永远当做函数调用，而不是方法。', '参数 array.reduce(f[,initial])', '{\"f\":\"%E4%B8%80%E4%B8%AA%E5%87%BD%E6%95%B0%EF%BC%8C%E5%8F%AF%E4%BB%A5%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E5%80%BC%EF%BC%88%E6%AF%94%E5%A6%82%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%EF%BC%89%EF%BC%8C%E5%B9%B6%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E2%80%9C%E7%BC%A9%E5%87%8F%E2%80%9D%E7%9A%84%E6%96%B0%E5%80%BC%E3%80%82\",\"initial\":\"%E7%94%A8%E6%9D%A5%E7%BC%A9%E5%87%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%8F%AF%E9%80%89%E5%88%9D%E5%A7%8B%E5%80%BC%E3%80%82%E5%A6%82%E6%9E%9C%E6%8C%87%E5%AE%9A%E8%AF%A5%E5%8F%82%E6%95%B0%EF%BC%8Creduce%28%29%E7%9A%84%E8%A1%8C%E4%B8%BA%E4%BC%9A%E5%83%8F%E6%98%AF%E6%8A%8A%E8%AF%A5%E5%8F%82%E6%95%B0%E6%8F%92%E5%85%A5array%E7%9A%84%E5%A4%B4%E9%83%A8%E4%B8%80%E6%A0%B7%E3%80%82\"}', '', '', '', '', '返回值', '数组的化简值，该值是最后一次调用f时的返回值。', '[1,2,3,4].reduce(function(x,y) { return x*y; }) // => 24: ((1*2)*3)*4'),
('/api_doc/Cookbook/Core', 'Array.reduce()_draft', '017', 'Array.reduce()', 'Core > Object > Array > reduce', '    reduce()方法接受函数f为第一个参数。该函数的行为应该像一个二元操作符一样：接受两个值，执行某些操作，然后返回结果。如果array有n个元素，reduce()方法会调用n-1次来将这些元素缩减为一个合并值。（你可能已经熟悉了数组缩减操作，在其他编程语言中，有时称为“折叠”或“注入”。）\r\n    第一次调用f时传人的是array的前两个元素。接下来的调用会传人之前的计算值和array的下一个元素（按照从小到大的序号顺序）。最后一次调用f的返回值会成为reduce()方法的返回值。\r\n    reduce()在调用时可以传人可选的第二个参数：initial。如果指定initial, reduce()的行为会像是把该参数插入array的头部一样（注意，实际上并没有修改array）。换一种说法是，就像reduce()带有两个参数调用，而initial就像是之前f的返回值一样。这种情况下，第一次调用f时传人的是initial以和array的第一个元素。当指定initial时，要缩减的元素有n+1个（array的n个元素，加上initial值），则调用n次f。\r\n    如果array为空，又没有指定initi以，reduce()舍抛出TypeError异常。如果array为空，但指定initial，则reduce()返回initial以，且永远不调用f。如果array只有一个元素，且没有指定initial，reduce()不调用，，会返回array的单个元素。\r\n    上面的段落描述了舶两个参数，实际上reduce()调用柙寸传人了4个参数。第三个参数是第二个参数的数组序号。第4个参数则是array自身。f永远当做函数调用，而不是方法。', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Array.reduceRight()', '018', 'Array.reduceRight()', 'Core > Object > Array > reduceRight', '    reduceRight()与reduce()方法一样：调用，函数n-1次，来将array的n个元素缩减为单个值。reduceRight()与reduce()只有一点不同：遍历数组时是从右到左（从最大的序号到最小的），而不是从左到右。细节请参考Array.reduce()。', '参数 array.reduceRight(f[,initial])', '{\"f\":\"%E4%B8%80%E4%B8%AA%E5%87%BD%E6%95%B0%EF%BC%8C%E5%8F%AF%E4%BB%A5%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E5%80%BC%EF%BC%88%E6%AF%94%E5%A6%82%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%EF%BC%89%EF%BC%8C%E5%B9%B6%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E2%80%9C%E7%BC%A9%E5%87%8F%E2%80%9D%E7%9A%84%E6%96%B0%E5%80%BC%E3%80%82\",\"initial\":\"%E7%94%A8%E6%9D%A5%E7%BC%A9%E5%87%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%8F%AF%E9%80%89%E5%88%9D%E5%A7%8B%E5%80%BC%E3%80%82%E5%A6%82%E6%9E%9C%E6%8C%87%E5%AE%9A%E8%AF%A5%E5%8F%82%E6%95%B0%EF%BC%8Creduce%28%29%E7%9A%84%E8%A1%8C%E4%B8%BA%E4%BC%9A%E5%83%8F%E6%98%AF%E6%8A%8A%E8%AF%A5%E5%8F%82%E6%95%B0%E6%8F%92%E5%85%A5array%E7%9A%84%E5%A4%B4%E9%83%A8%E4%B8%80%E6%A0%B7%E3%80%82\"}', '', '', '', '', '返回值', '数组的缩减值，该值是最后一次调用f时的返回值。', '[2, 10, 60].reduceRight(function(x,y) { return x/y }) // => 3: (60/10)/2'),
('/api_doc/Cookbook/Core', 'Array.reverse()', '019', 'Array.reverse()', 'Core > Object > Array > reverse', '    Array对象的reverse()方法可以颠倒数组元素的顺序。它会在原数组中进行操作：重新调整array中的元素，而不会创建一个新数组。如果array有多个引用，该数组元素的新顺序在所有引用中可见。', '', '', '', '', '', '', '', '', 'a = new Array(1, 2, 3);    // a[0] == 1, a[2] == 3;\r\na.reverse();                   // Now a[0] == 3, a[2] == 1;'),
('/api_doc/Cookbook/Core', 'Array.shift()', '020', 'Array.shift()', 'Core > Object > Array > shift', '    shift()会移除并返回array的第一个元素，并将所有后续元素前移一位，以填补数组头部的空缺。如果数组为空，shift()什么也不干，直接返回undefined值。注意shift()没有创建新数组，它会直接修改array。\r\n    shift()与Array．pop()类似，除了操作的是数组的头部而不是尾部。shift()经常与unshift()一起使用。', '', '', '', '', '', '', '返回值', '数组原来的第一个元素。', 'var a = [1, [2,3], 4]\r\na.shift(); // Returns 1; a = [[2,3], 4]\r\na.shift(); // Returns [2,3]; a = [4]'),
('/api_doc/Cookbook/Core', 'Array.slice()', '021', 'Array.slice()', 'Core > Object > Array > slice', '    slice()返回array的片段，或称为子数组。返回的数组包含从start一直到end之间的所有元素（包含start指定的元素，但不包含end指定的元素）。如果没有指定end，返回的数组包含从start到array尾部的所有元素。\r\n    注意slice()没有修改数组。如果想要移除数组的一部分，请使用Array．splice()。', '参数 array.slice(start[,end])', '{\"start\":\"%E6%95%B0%E7%BB%84%E7%89%87%E6%AE%B5%E5%BC%80%E5%A7%8B%E5%A4%84%E7%9A%84%E6%95%B0%E7%BB%84%E5%BA%8F%E5%8F%B7%E3%80%82%E5%A6%82%E6%9E%9C%E4%B8%BA%E8%B4%9F%E6%95%B0%EF%BC%8C%E5%88%99%E8%A1%A8%E7%A4%BA%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%B0%BE%E9%83%A8%E5%BC%80%E5%A7%8B%E8%AE%A1%E7%AE%97%E3%80%82%E4%B9%9F%E5%B0%B1%E6%98%AF%E8%AF%B4%EF%BC%8C-1%E4%BB%A3%E8%A1%A8%E6%9C%80%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%EF%BC%8C-2%E4%BB%A3%E8%A1%A8%E5%80%92%E6%95%B0%E7%AC%AC%E4%BA%8C%E4%B8%AA%E5%85%83%E7%B4%A0%EF%BC%8C%E4%BB%A5%E6%AD%A4%E7%B1%BB%E6%8E%A8%E3%80%82\",\"end\":\"%E6%95%B0%E7%BB%84%E7%89%87%E6%AE%B5%E7%BB%93%E6%9D%9F%E5%A4%84%E7%9A%84%E5%90%8E%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%E7%9A%84%E6%95%B0%E7%BB%84%E5%BA%8F%E5%8F%B7%E3%80%82%E5%A6%82%E6%9E%9C%E6%B2%A1%E6%9C%89%E6%8C%87%E5%AE%9A%EF%BC%8C%E8%AF%A5%E7%89%87%E6%AE%B5%E4%BC%9A%E5%8C%85%E5%90%AB%E4%BB%8Estart%E5%BC%80%E5%A7%8B%E5%88%B0%E6%95%B0%E7%BB%84%E5%B0%BE%E9%83%A8%E7%9A%84%E6%89%80%E6%9C%89%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E3%80%82%E5%A6%82%E6%9E%9C%E4%B8%BA%E8%B4%9F%E6%95%B0%EF%BC%8C%E5%88%99%E8%A1%A8%E7%A4%BA%E4%BB%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%B0%BE%E9%83%A8%E5%BC%80%E5%A7%8B%E8%AE%A1%E7%AE%97%E3%80%82\"}', '', '', '', '', '返回值', '一个新数组，包含array中从start一直到end之间的所有元素（包含start指定的元素，但不包含end指定的元素）。', 'var a = [1,2,3,4,5];\r\na.slice(0,3);   // Returns [1,2,3]\r\na.slice(3);      // Returns [4,5]\r\na.slice(1,-1);  // Returns [2,3,4]\r\na.slice(-3,-2); // Returns [3]; buggy in IE 4: returns [1,2,3]'),
('/api_doc/Cookbook/Core', 'Array.some()', '022', 'Array.some()', 'Core > Object > Array > some', '    some()方法用来测试数组中是否有元素满足某些条件。它会按照从小到大的顺序遍历array的元素，并依次对每个元素调用指定的predicate函数。如果predicate返回true（或任何可以转化为true的值），则some()会停止遍历，并立刻返回true。如果predicate的每一次调用都返回false（或任何可以转化为false的值），则some()返回false。当遍历的数组为空时，some()返回false。\r\n    该方法很类似every()。更多细节请参考Array.every()和Array.forEach()。', '参数 array.some(predicate[,o])', '{\"predicate\":\"%E7%94%A8%E6%9D%A5%E6%B5%8B%E8%AF%95%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E6%96%AD%E8%A8%80%E5%87%BD%E6%95%B0%E3%80%82\",\"o\":\"%E8%B0%83%E7%94%A8predicate%E6%97%B6%E5%8F%AF%E9%80%89%E7%9A%84this%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '如果array中有至少一个元素调用predicate时返回真值，则返回true。如果所有元素调用predicate时都返回假值，则返回false。', '[1,2,3].some(function(x) { return x > 5; }) // => false: no elts are > 5\r\n[1,2,3].some(function(x) { return x > 2; }) // => true: some elts are > 3\r\n[].some(function(x) { return true; });         // => false: always false for []'),
('/api_doc/Cookbook/Core', 'Array.sort()', '023', 'Array.sort()', 'Core > Object > Array > sort', '    sort()方法在原数组中对数组元素进行排序，没有创建新数组。如果在调用sort()时不带参数，将按字母顺序（更精确地说，是字符编码顺序）对数组中的元素进行排序。要实现这一点，首先要把元素转化为字符串（如果有必要的话），以便进行比较。\r\n    如果想按照其他顺序来进行排序，就必须提供比较函数，该函数要比较两个值，然后返回一个数字来表明这两个值的相对顺序。比较函数需要接受两个参数a和b，并返回如下值：\r\n    ·  一个小于0的值。在这种情况下，表示根据排序标准，a小于b，在排序后的数组中，a应该排列在b的前面。\r\n    ·  0。在这种排序下，a和b是相等的。\r\n    ·  一个大于0的值。在这种情况下，a大于b。', '参数 array.sort([orderfunc])', '{\"orderfunc\":\"%E7%94%A8%E6%9D%A5%E6%8C%87%E5%AE%9A%E5%A6%82%E4%BD%95%E6%8E%92%E5%BA%8F%E7%9A%84%E5%8F%AF%E9%80%89%E5%87%BD%E6%95%B0\"}', '', '', '', '', '返回值', '该数组的引用。注意是在原数组中进行排序，没有新建数组。', '// An ordering function for a numerical sort\r\nfunction numberorder(a, b) { return a - b; }\r\na = new Array(33, 4, 1111, 222);\r\na.sort(); // Alphabetical sort: 1111, 222, 33, 4\r\na.sort(numberorder); // Numerical sort: 4, 33, 222, 1111'),
('/api_doc/Cookbook/Core', 'Array.splice()', '024', 'Array.splice()', 'Core > Object > Array > splice', '    splice()将删除从start开始（包括start处）的零个或多个元素，并且用参数列表中指定的零个或多个值来替换掉那些删除的元素。位于插入或删除的元素之后的数组元素，在有必要时都会移动，以保持与数组中剩余元素的连续性。注意，虽然splice()与slice()的方法名类似，但作用不是类似的，splice()会直接修改数组。', '参数 array.splice(start,deleteCount,value[,...])', '{\"start\":\"%E5%BC%80%E5%A7%8B%E6%8F%92%E5%85%A5%E5%92%8C%EF%BC%88%E6%88%96%EF%BC%89%E5%88%A0%E9%99%A4%E5%A4%84%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E5%BA%8F%E5%8F%B7%E3%80%82\",\"deleteCount\":\"%E8%A6%81%E5%88%A0%E9%99%A4%E7%9A%84%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%EF%BC%8C%E4%BB%8Estart%E5%BC%80%E5%A7%8B%EF%BC%8C%E5%B9%B6%E5%8C%85%E5%90%ABstart%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0%E3%80%82%E5%A6%82%E6%9E%9C%E6%8C%87%E5%AE%9A%E4%B8%BA0%EF%BC%8C%E8%A1%A8%E7%A4%BA%E6%8F%92%E5%85%A5%E5%85%83%E7%B4%A0%EF%BC%8C%E8%80%8C%E4%B8%8D%E7%94%A8%E5%88%A0%E9%99%A4%E4%BB%BB%E4%BD%95%E5%85%83%E7%B4%A0%E3%80%82\",\"value,...\":\"%E8%A6%81%E6%8F%92%E5%85%A5%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E9%9B%B6%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E5%80%BC%EF%BC%8C%E4%BB%8Estart%E5%BA%8F%E5%8F%B7%E5%A4%84%E5%BC%80%E5%A7%8B%E6%8F%92%E5%85%A5%E3%80%82\"}', '', '', '', '', '返回值', '如果从array中删除了元素，则返回一个新数组，包含这些删除的元素。', 'var a = [1,2,3,4,5,6,7,8]\r\na.splice(1,2); // Returns [2,3]; a is [1,4]\r\na.splice(1,1); // Returns [4]; a is [1]\r\na.splice(1,0,2,3); // Returns []; a is [1 2 3]'),
('/api_doc/Cookbook/Core', 'Array.toLocaleString()', '025', 'Array.toLocaleString()', 'Core > Object > Array > toLocaleString', '    数组的toLocaleString()方法返回数组的本地化字符串表示。它首先调用所有数组元素的toLocaleString()方法，然后使用地区特定的分隔字符将结果字符串连接起来。\r\n\r\n     异常  TypeError\r\n     调用该方法时，如何对象不是Array，则抛出该异常。', '', '', '', '', '', '', '返回值', '数组的本地化字符串表示。', ''),
('/api_doc/Cookbook/Core', 'Array.toStirng()', '026', 'Array.toStirng()', 'Core > Object > Array > toStirng', '    数组的toString()方法把数组转化成字符串，并返回该字符串。当数组用于字符串上下文中时，JavaScript会调用该方法将数组自动转换成一个字符串。但是，在某些场景下，还是需要显式调用toString()方法。\r\n\r\n    异常  TypeError\r\n    调用该方法时，如何对象不是Array，则抛出该异常。', '', '', '', '', '', '', '返回值', 'array的字符串表示。', ''),
('/api_doc/Cookbook/Core', 'Array.unshift()', '027', 'Array.unshift()', 'Core > Object > Array > unshift', '    unshift()会把参数插入array的头部，并将已经存在的元素顺次往后移动，以便留出空间。该方法的第一个参数会成为数组新的元素0，如果还有第二个参数的话，会成为新的元素1，以此类推。注意，unshift()不会创建新数组，而是直接修改数组本身。', '参数 array.unshift(value[,...])', '{\"value,...\":\"%E8%A6%81%E6%8F%92%E5%85%A5array%E5%A4%B4%E9%83%A8%E7%9A%84%E4%B8%80%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E5%80%BC%E3%80%82\"}', '', '', '', '', '返回值', '数组的新长度', 'var a = []; // a:[]\r\na.unshift(1);    // a:[1] Returns: 1\r\na.unshift(22);  // a:[22,1] Returns: 2\r\na.shift();          // a:[1] Returns: 22\r\na.unshift(33,[4,5]); // a:[33,[4,5],1] Returns: 3'),
('/api_doc/Cookbook/Core', 'Global', '000', 'Global(预定义对象，并非真正存在)', 'Core > Global', '    全局对象是一个预定义对象，用做JavaScript中全局属性和全局函数的占位符。通过全局对象，可以访问所有其他预定义的对象、函数和属性。全局对象不是任何对象的属性，因此它没有名字（之所以选择Global作为该参考页的标题，只是为了方便组织，并不是说全局对象的名字为Global）。在全局JavaScript代码中，可以用关键字this来引用全局对象。但通常不必用这种方式来引用全局对象，因为全局对象是作用域链的头，这意味着所有不合格的变量和函数名都会作为全局对象的属性来查询。例如，当JavaScript代码引用parselnt()函数时，它引用的就是全局对象的parselnt属性。全局对象是作用域链的头，还意味着在全局JavaScript代码中声明的所有变量都将成为全局对象的属性。\r\n    全局对象只是一个对象，而不是类。不存在Global()构造函数，也就无法实例化一个新的全局对象。\r\n    当JavaScript代码嵌入一个特定环境时，全局对象通用具有与该特定环境相关的额外属性。实际上，ECMAScript标准没有规定全局对象的类型，JavaScript的实现或嵌入环境可以使用任意类型的对象来作为全局对象．只要该对象定义了这里列举的基本属性和方法。例如，在客户端JavaScript中，全局对象是Window对象，表示运行JavaScript代码的Web浏览器窗口。', '', '', '全局属性(不用通过Global.的方式获取，而是直接就可以使用)', '{\"Infinity\":\"%E8%A1%A8%E7%A4%BA%E6%AD%A3%E6%97%A0%E7%A9%B7%E5%A4%A7%E7%9A%84%E6%95%B0%E5%80%BC%E3%80%82\",\"NaN\":\"%E8%A1%A8%E7%A4%BA%E4%B8%8D%E6%98%AF%E6%95%B0%E5%80%BC%E7%9A%84%E5%80%BC%E3%80%82\",\"undefined\":\"undefined%E5%80%BC%E3%80%82\"}', '全局函数和全局对象', '{\"decodeURI()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8encodeURI%28%29%E8%BD%AC%E4%B9%89%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"decodeURIComponent()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8encodeURIComponent%28%29%E8%BD%AC%E4%B9%89%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"encodeURI()\":\"%E9%80%9A%E8%BF%87%E8%BD%AC%E4%B9%89%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9URI%E7%BC%96%E7%A0%81%E3%80%82\",\"encodeURIComponent()\":\"%E9%80%9A%E8%BF%87%E8%BD%AC%E4%B9%89%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9URI%E7%9A%84%E7%BB%84%E6%88%90%E9%83%A8%E5%88%86%E7%BC%96%E7%A0%81%E3%80%82\",\"escape()\":\"%E7%94%A8%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97%E6%9B%BF%E6%8D%A2%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%BC%96%E7%A0%81%E3%80%82\",\"eval()\":\"%E6%89%A7%E8%A1%8CJavaScript%E4%BB%A3%E7%A0%81%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E8%BF%94%E5%9B%9E%E7%BB%93%E6%9E%9C%E3%80%82\",\"isFinite()\":\"%E6%80%95%E6%AE%B5%E4%B8%80%E4%B8%AA%E5%80%BC%E6%98%AF%E5%90%A6%E6%97%A0%E7%A9%B7%E3%80%82\",\"isNaN()\":\"%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E5%80%BC%E6%98%AF%E5%90%A6%E6%98%AF%E9%9D%9E%E6%95%B0%E5%80%BC%E3%80%82\",\"parseFloat()\":\"%E4%BB%8E%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E8%A7%A3%E6%9E%90%E6%95%B0%E5%80%BC%E4%B8%BA%E6%B5%AE%E7%82%B9%E6%95%B0%E3%80%82\",\"parseInt()\":\"%E4%BB%8E%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E8%A7%A3%E6%9E%90%E6%95%B4%E6%95%B0%E3%80%82\",\"unescape()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8escape%28%29%E7%BC%96%E7%A0%81%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"Array\":\"Array%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Boolean\":\"Boolean%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Date\":\"Date%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Error\":\"Error%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"EvalError\":\"EvalError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Function\":\"Function%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"JSON\":\"JSON%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Math\":\"Math%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Number\":\"Number%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Object\":\"Object%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"RangeError\":\"RangeError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"ReferenceError\":\"ReferenceError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"RegExp\":\"RegExp%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"String\":\"String%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"SyntaxError\":\"SyntaxError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"TypeError\":\"TypeError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"URIError\":\"URIError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\"}', '', '', ''),
('/api_doc/Cookbook/Core', 'Global_draft', '000', 'Global(预定义对象，并非真正存在)', 'Core > Global', '    全局对象是一个预定义对象，用做JavaScript中全局属性和全局函数的占位符。通过全局对象，可以访问所有其他预定义的对象、函数和属性。全局对象不是任何对象的属性，因此它没有名字（之所以选择Global作为该参考页的标题，只是为了方便组织，并不是说全局对象的名字为Global）。在全局JavaScript代码中，可以用关键字this来引用全局对象。但通常不必用这种方式来引用全局对象，因为全局对象是作用域链的头，这意味着所有不合格的变量和函数名都会作为全局对象的属性来查询。例如，当JavaScript代码引用parselnt()函数时，它引用的就是全局对象的parselnt属性。全局对象是作用域链的头，还意味着在全局JavaScript代码中声明的所有变量都将成为全局对象的属性。\r\n    全局对象只是一个对象，而不是类。不存在Global()构造函数，也就无法实例化一个新的全局对象。\r\n    当JavaScript代码嵌入一个特定环境时，全局对象通用具有与该特定环境相关的额外属性。实际上，ECMAScript标准没有规定全局对象的类型，JavaScript的实现或嵌入环境可以使用任意类型的对象来作为全局对象．只要该对象定义了这里列举的基本属性和方法。例如，在客户端JavaScript中，全局对象是Window对象，表示运行JavaScript代码的Web浏览器窗口。', '', '', '全局属性(不用通过Global.的方式获取，而是直接就可以使用)', '{\"Infinity\":\"%E8%A1%A8%E7%A4%BA%E6%AD%A3%E6%97%A0%E7%A9%B7%E5%A4%A7%E7%9A%84%E6%95%B0%E5%80%BC%E3%80%82\",\"NaN\":\"%E8%A1%A8%E7%A4%BA%E4%B8%8D%E6%98%AF%E6%95%B0%E5%80%BC%E7%9A%84%E5%80%BC%E3%80%82\",\"undefined\":\"undefined%E5%80%BC%E3%80%82\"}', '全局函数和全局对象', '{\"decodeURI()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8encodeURI%28%29%E8%BD%AC%E4%B9%89%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"decodeURIComponent()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8encodeURIComponent%28%29%E8%BD%AC%E4%B9%89%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"encodeURI()\":\"%E9%80%9A%E8%BF%87%E8%BD%AC%E4%B9%89%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9URI%E7%BC%96%E7%A0%81%E3%80%82\",\"encodeURIComponent()\":\"%E9%80%9A%E8%BF%87%E8%BD%AC%E4%B9%89%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9URI%E7%9A%84%E7%BB%84%E6%88%90%E9%83%A8%E5%88%86%E7%BC%96%E7%A0%81%E3%80%82\",\"escape()\":\"%E7%94%A8%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97%E6%9B%BF%E6%8D%A2%E7%89%B9%E5%AE%9A%E5%AD%97%E7%AC%A6%E5%AF%B9%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%BC%96%E7%A0%81%E3%80%82\",\"eval()\":\"%E6%89%A7%E8%A1%8CJavaScript%E4%BB%A3%E7%A0%81%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E8%BF%94%E5%9B%9E%E7%BB%93%E6%9E%9C%E3%80%82\",\"isFinite()\":\"%E6%80%95%E6%AE%B5%E4%B8%80%E4%B8%AA%E5%80%BC%E6%98%AF%E5%90%A6%E6%97%A0%E7%A9%B7%E3%80%82\",\"isNaN()\":\"%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E5%80%BC%E6%98%AF%E5%90%A6%E6%98%AF%E9%9D%9E%E6%95%B0%E5%80%BC%E3%80%82\",\"parseFloat()\":\"%E4%BB%8E%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E8%A7%A3%E6%9E%90%E6%95%B0%E5%80%BC%E4%B8%BA%E6%B5%AE%E7%82%B9%E6%95%B0%E3%80%82\",\"parseInt()\":\"%E4%BB%8E%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E8%A7%A3%E6%9E%90%E6%95%B4%E6%95%B0%E3%80%82\",\"unescape()\":\"%E8%A7%A3%E7%A0%81%E4%BD%BF%E7%94%A8escape%28%29%E7%BC%96%E7%A0%81%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\",\"Array\":\"Array%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Boolean\":\"Boolean%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Date\":\"Date%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Error\":\"Error%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"EvalError\":\"EvalError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Function\":\"Function%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"JSON\":\"JSON%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Math\":\"Math%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Number\":\"Number%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"Object\":\"Object%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"RangeError\":\"RangeError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"ReferenceError\":\"ReferenceError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"RegExp\":\"RegExp%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"String\":\"String%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"SyntaxError\":\"SyntaxError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"TypeError\":\"TypeError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\",\"URIError\":\"URIError%28%29%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E3%80%82\"}', '', '', ''),
('/api_doc/Cookbook/Core', 'Object', '040', 'Object', 'Core > Object > ', '    包含所有JavaScript对象的特性的超类。\r\n\r\n    构造函数：\r\n        new Object()\r\n        new Object(value)\r\n\r\n    Object类是JavaScript语言的内置数据类型。它是所有其他JavaScript对象的超类，因此，Object类的所有方法和行为都被其他对象继承了。', '参数', '{\"value\":\"%E8%BF%99%E4%B8%AA%E5%8F%AF%E9%80%89%E7%9A%84%E5%8F%82%E6%95%B0%E6%8C%87%E5%AE%9A%E4%B8%80%E4%B8%AA%E5%8E%9F%E5%A7%8B%E7%9A%84JavaScript%E5%80%BC%E2%80%94%E2%80%94%E4%B8%80%E4%B8%AA%E6%95%B0%E5%AD%97%E3%80%81%E5%B8%83%E5%B0%94%E5%80%BC%E6%88%96%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E8%BF%99%E4%BA%9B%E5%80%BC%E5%B0%86%E5%88%86%E5%88%AB%E8%BD%AC%E6%8D%A2%E4%B8%BA%E4%B8%80%E4%B8%AANumber%E3%80%81Boolean%E6%88%96String%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '属性', '{\"constructor\":\"%E5%BC%95%E7%94%A8%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%EF%BC%88%E4%B8%80%E4%B8%AAJavaScript%E5%87%BD%E6%95%B0%EF%BC%89%E3%80%82\"}', '方法/静态方法', '{\"hasOwnProperty()\":\"%E6%A3%80%E6%9F%A5%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E6%8B%A5%E6%9C%89%E4%B8%80%E4%B8%AA%E6%8C%87%E5%AE%9A%E5%90%8D%E5%AD%97%E7%9A%84%E6%9C%AC%E5%9C%B0%E5%AE%9A%E4%B9%89%EF%BC%88%E8%80%8C%E4%B8%8D%E6%98%AF%E7%BB%A7%E6%89%BF%EF%BC%89%E7%9A%84%E5%B1%9E%E6%80%A7%E3%80%82\",\"isPrototypeOf()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E4%B8%8D%E6%98%AF%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%E3%80%82\",\"propertyIsEnumerable()\":\"%E6%A3%80%E6%9F%A5%E6%8C%87%E5%AE%9A%E5%90%8D%E5%AD%97%E7%9A%84%E5%B1%9E%E6%80%A7%E6%98%AF%E5%90%A6%E5%AD%98%E5%9C%A8%E5%B9%B6%E4%B8%94%E5%8F%AF%E4%BB%A5%E7%94%A8for%2Fin%E5%BE%AA%E7%8E%AF%E6%9E%9A%E4%B8%BE%E3%80%82\",\"toLocaleString()\":\"%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E6%9C%AC%E5%9C%B0%E5%8C%96%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%A1%A8%E7%A4%BA%E3%80%82%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E7%9A%84%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%8F%AA%E6%98%AF%E7%AE%80%E5%8D%95%E5%9C%B0%E8%B0%83%E7%94%A8toString%28%29%EF%BC%8C%E4%B8%8D%E8%BF%87%E5%AD%90%E7%B1%BB%E5%8F%AF%E4%BB%A5%E8%A6%86%E7%9B%96%E5%AE%83%EF%BC%8C%E4%BB%A5%E4%BE%BF%E6%8F%90%E4%BE%9B%E6%9C%AC%E5%9C%B0%E5%8C%96%E5%AE%9E%E7%8E%B0%E3%80%82\",\"toString()\":\"%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%A1%A8%E7%A4%BA%E3%80%82Object%E7%B1%BB%E5%AE%9E%E7%8E%B0%E7%9A%84%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E9%9D%9E%E5%B8%B8%E5%AE%BD%E6%B3%9B%EF%BC%8C%E4%B8%8D%E8%83%BD%E6%8F%90%E4%BE%9B%E5%BE%88%E5%A4%9A%E6%9C%89%E7%94%A8%E7%9A%84%E4%BF%A1%E6%81%AF%E3%80%82Object%E7%9A%84%E5%AD%90%E7%B1%BB%E9%80%9A%E5%B8%B8%E4%BC%9A%E9%80%9A%E8%BF%87%E8%87%AA%E5%AE%9A%E4%B9%89%E7%9A%84toString%28%29%E6%96%B9%E6%B3%95%E6%9D%A5%E5%B0%86%E5%AE%83%E8%A6%86%E7%9B%96%EF%BC%8C%E4%BB%A5%E4%BE%BF%E6%8F%90%E4%BE%9B%E6%9B%B4%E5%A4%9A%E6%9C%89%E7%94%A8%E7%9A%84%E8%BE%93%E5%87%BA%E4%BF%A1%E6%81%AF%E3%80%82\",\"valueOf()\":\"%E8%BF%94%E5%9B%9E%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%A7%8B%E5%80%BC%EF%BC%8C%E5%A6%82%E6%9E%9C%E5%AD%98%E5%9C%A8%E5%8E%9F%E5%A7%8B%E5%80%BC%E7%9A%84%E8%AF%9D%E3%80%82%E5%AF%B9%E7%B1%BB%E5%9E%8B%E4%B8%BAObject%E7%9A%84%E5%AF%B9%E8%B1%A1%E6%9D%A5%E8%AF%B4%EF%BC%8C%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E5%8F%AA%E6%98%AF%E7%AE%80%E5%8D%95%E5%9C%B0%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E6%9C%AC%E8%BA%AB%E3%80%82Object%E7%9A%84%E5%AD%90%E7%B1%BB%EF%BC%88%E5%A6%82Number%E3%80%81Boolean%EF%BC%89%E5%88%99%E9%87%8D%E8%BD%BD%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%EF%BC%8C%E4%BB%A5%E4%BE%BF%E8%BF%94%E5%9B%9E%E4%B8%8E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9B%B8%E5%85%B3%E7%9A%84%E5%8E%9F%E5%A7%8B%E5%80%BC%E3%80%82\",\"Object.create()\":\"%E4%BD%BF%E7%94%A8%E6%8C%87%E5%AE%9A%E7%9A%84%E5%8E%9F%E5%9E%8B%E5%8F%8A%E5%B1%9E%E6%80%A7%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%96%B0%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"Object.defineProperties()\":\"%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.defineProperty()\":\"%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%9F%90%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.freeze()\":\"%E5%B0%86%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E8%AE%BE%E7%BD%AE%E4%B8%BA%E4%B8%8D%E5%8F%AF%E6%94%B9%E5%8F%98%E3%80%82\",\"Object.getOwnPropertyDescriptor()\":\"%E6%9F%A5%E8%AF%A2%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%8C%87%E5%AE%9A%E5%B1%9E%E6%80%A7%E7%9A%84%E7%89%B9%E6%80%A7%E3%80%82\",\"Object.getOwnPropertyNames()\":\"%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E5%8C%85%E5%90%AB%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%89%80%E6%9C%89%E9%9D%9E%E7%BB%A7%E6%89%BF%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E6%95%B0%E7%BB%84%EF%BC%8C%E5%8C%85%E6%8B%AC%E4%B8%8D%E5%8F%AF%E6%9E%9A%E4%B8%BE%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.getPrototypeOf()\":\"%E8%BF%94%E5%9B%9E%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%E3%80%82\",\"Object.isExtensible()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E8%83%BD%E6%B7%BB%E5%8A%A0%E5%88%B0%E6%96%B0%E7%9A%84%E5%B1%9E%E6%80%A7%E4%B8%AD%E3%80%82\",\"Object.isFrozen()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E5%B7%B2%E5%86%BB%E7%BB%93%E3%80%82\",\"Object.isSealed()\":\"%E6%A3%80%E6%9F%A5%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E4%B8%BA%E5%B0%81%E9%97%AD%E7%9A%84%28sealed%29%E3%80%82\",\"Object.keys()\":\"%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E5%8C%85%E5%90%AB%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%89%80%E6%9C%89%E9%9D%9E%E7%BB%A7%E6%89%BF%E5%8F%AF%E6%9E%9A%E4%B8%BE%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E6%95%B0%E7%BB%84%E3%80%82\",\"Object.preventExtensions()\":\"%E9%98%BB%E6%AD%A2%E5%90%91%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%B7%BB%E5%8A%A0%E6%96%B0%E7%9A%84%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.seal()\":\"%E9%98%BB%E6%AD%A2%E5%90%91%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%B7%BB%E5%8A%A0%E6%96%B0%E5%B1%9E%E6%80%A7%E6%88%96%E5%88%A0%E9%99%A4%E7%8E%B0%E6%9C%89%E5%B1%9E%E6%80%A7%E3%80%82\"}', '返回值', '如果没有传人value参数，则这个构造函数将返回一个新创建的Object实例。如果传人一个原始value值，则构造函数将创建并返回一个原始值的Number、Boolean或String对象封装。如果不带new操作符，将Object()构造函数像函数那样调用，则它的行为将和使用new操作符时一样。', ''),
('/api_doc/Cookbook/Core', 'Object_draft', '040', 'Object', 'Core > Object > ', '    包含所有JavaScript对象的特性的超类。\r\n\r\n    构造函数：\r\n        new Object()\r\n        new Object(value)\r\n\r\n    Object类是JavaScript语言的内置数据类型。它是所有其他JavaScript对象的超类，因此，Object类的所有方法和行为都被其他对象继承了。', '参数', '{\"value\":\"%E8%BF%99%E4%B8%AA%E5%8F%AF%E9%80%89%E7%9A%84%E5%8F%82%E6%95%B0%E6%8C%87%E5%AE%9A%E4%B8%80%E4%B8%AA%E5%8E%9F%E5%A7%8B%E7%9A%84JavaScript%E5%80%BC%E2%80%94%E2%80%94%E4%B8%80%E4%B8%AA%E6%95%B0%E5%AD%97%E3%80%81%E5%B8%83%E5%B0%94%E5%80%BC%E6%88%96%E5%AD%97%E7%AC%A6%E4%B8%B2%EF%BC%8C%E8%BF%99%E4%BA%9B%E5%80%BC%E5%B0%86%E5%88%86%E5%88%AB%E8%BD%AC%E6%8D%A2%E4%B8%BA%E4%B8%80%E4%B8%AANumber%E3%80%81Boolean%E6%88%96String%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '属性', '{\"constructor\":\"%E5%BC%95%E7%94%A8%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%EF%BC%88%E4%B8%80%E4%B8%AAJavaScript%E5%87%BD%E6%95%B0%EF%BC%89%E3%80%82\"}', '方法/静态方法', '{\"hasOwnProperty()\":\"%E6%A3%80%E6%9F%A5%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E6%8B%A5%E6%9C%89%E4%B8%80%E4%B8%AA%E6%8C%87%E5%AE%9A%E5%90%8D%E5%AD%97%E7%9A%84%E6%9C%AC%E5%9C%B0%E5%AE%9A%E4%B9%89%EF%BC%88%E8%80%8C%E4%B8%8D%E6%98%AF%E7%BB%A7%E6%89%BF%EF%BC%89%E7%9A%84%E5%B1%9E%E6%80%A7%E3%80%82\",\"isPrototypeOf()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E4%B8%8D%E6%98%AF%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%E3%80%82\",\"propertyIsEnumerable()\":\"%E6%A3%80%E6%9F%A5%E6%8C%87%E5%AE%9A%E5%90%8D%E5%AD%97%E7%9A%84%E5%B1%9E%E6%80%A7%E6%98%AF%E5%90%A6%E5%AD%98%E5%9C%A8%E5%B9%B6%E4%B8%94%E5%8F%AF%E4%BB%A5%E7%94%A8for%2Fin%E5%BE%AA%E7%8E%AF%E6%9E%9A%E4%B8%BE%E3%80%82\",\"toLocaleString()\":\"%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E6%9C%AC%E5%9C%B0%E5%8C%96%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%A1%A8%E7%A4%BA%E3%80%82%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E7%9A%84%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%8F%AA%E6%98%AF%E7%AE%80%E5%8D%95%E5%9C%B0%E8%B0%83%E7%94%A8toString%28%29%EF%BC%8C%E4%B8%8D%E8%BF%87%E5%AD%90%E7%B1%BB%E5%8F%AF%E4%BB%A5%E8%A6%86%E7%9B%96%E5%AE%83%EF%BC%8C%E4%BB%A5%E4%BE%BF%E6%8F%90%E4%BE%9B%E6%9C%AC%E5%9C%B0%E5%8C%96%E5%AE%9E%E7%8E%B0%E3%80%82\",\"toString()\":\"%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%A1%A8%E7%A4%BA%E3%80%82Object%E7%B1%BB%E5%AE%9E%E7%8E%B0%E7%9A%84%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E9%9D%9E%E5%B8%B8%E5%AE%BD%E6%B3%9B%EF%BC%8C%E4%B8%8D%E8%83%BD%E6%8F%90%E4%BE%9B%E5%BE%88%E5%A4%9A%E6%9C%89%E7%94%A8%E7%9A%84%E4%BF%A1%E6%81%AF%E3%80%82Object%E7%9A%84%E5%AD%90%E7%B1%BB%E9%80%9A%E5%B8%B8%E4%BC%9A%E9%80%9A%E8%BF%87%E8%87%AA%E5%AE%9A%E4%B9%89%E7%9A%84toString%28%29%E6%96%B9%E6%B3%95%E6%9D%A5%E5%B0%86%E5%AE%83%E8%A6%86%E7%9B%96%EF%BC%8C%E4%BB%A5%E4%BE%BF%E6%8F%90%E4%BE%9B%E6%9B%B4%E5%A4%9A%E6%9C%89%E7%94%A8%E7%9A%84%E8%BE%93%E5%87%BA%E4%BF%A1%E6%81%AF%E3%80%82\",\"valueOf()\":\"%E8%BF%94%E5%9B%9E%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%A7%8B%E5%80%BC%EF%BC%8C%E5%A6%82%E6%9E%9C%E5%AD%98%E5%9C%A8%E5%8E%9F%E5%A7%8B%E5%80%BC%E7%9A%84%E8%AF%9D%E3%80%82%E5%AF%B9%E7%B1%BB%E5%9E%8B%E4%B8%BAObject%E7%9A%84%E5%AF%B9%E8%B1%A1%E6%9D%A5%E8%AF%B4%EF%BC%8C%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%E5%8F%AA%E6%98%AF%E7%AE%80%E5%8D%95%E5%9C%B0%E8%BF%94%E5%9B%9E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E6%9C%AC%E8%BA%AB%E3%80%82Object%E7%9A%84%E5%AD%90%E7%B1%BB%EF%BC%88%E5%A6%82Number%E3%80%81Boolean%EF%BC%89%E5%88%99%E9%87%8D%E8%BD%BD%E8%BF%99%E4%B8%AA%E6%96%B9%E6%B3%95%EF%BC%8C%E4%BB%A5%E4%BE%BF%E8%BF%94%E5%9B%9E%E4%B8%8E%E8%AF%A5%E5%AF%B9%E8%B1%A1%E7%9B%B8%E5%85%B3%E7%9A%84%E5%8E%9F%E5%A7%8B%E5%80%BC%E3%80%82\",\"Object.create()\":\"%E4%BD%BF%E7%94%A8%E6%8C%87%E5%AE%9A%E7%9A%84%E5%8E%9F%E5%9E%8B%E5%8F%8A%E5%B1%9E%E6%80%A7%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%96%B0%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"Object.defineProperties()\":\"%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%80%E4%B8%AA%E6%88%96%E5%A4%9A%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.defineProperty()\":\"%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%9F%90%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.freeze()\":\"%E5%B0%86%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E8%AE%BE%E7%BD%AE%E4%B8%BA%E4%B8%8D%E5%8F%AF%E6%94%B9%E5%8F%98%E3%80%82\",\"Object.getOwnPropertyDescriptor()\":\"%E6%9F%A5%E8%AF%A2%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%8C%87%E5%AE%9A%E5%B1%9E%E6%80%A7%E7%9A%84%E7%89%B9%E6%80%A7%E3%80%82\",\"Object.getOwnPropertyNames()\":\"%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E5%8C%85%E5%90%AB%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%89%80%E6%9C%89%E9%9D%9E%E7%BB%A7%E6%89%BF%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E6%95%B0%E7%BB%84%EF%BC%8C%E5%8C%85%E6%8B%AC%E4%B8%8D%E5%8F%AF%E6%9E%9A%E4%B8%BE%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.getPrototypeOf()\":\"%E8%BF%94%E5%9B%9E%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%E3%80%82\",\"Object.isExtensible()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E8%83%BD%E6%B7%BB%E5%8A%A0%E5%88%B0%E6%96%B0%E7%9A%84%E5%B1%9E%E6%80%A7%E4%B8%AD%E3%80%82\",\"Object.isFrozen()\":\"%E6%A3%80%E6%9F%A5%E5%BD%93%E5%89%8D%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E5%B7%B2%E5%86%BB%E7%BB%93%E3%80%82\",\"Object.isSealed()\":\"%E6%A3%80%E6%9F%A5%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%90%A6%E4%B8%BA%E5%B0%81%E9%97%AD%E7%9A%84%28sealed%29%E3%80%82\",\"Object.keys()\":\"%E8%BF%94%E5%9B%9E%E4%B8%80%E4%B8%AA%E5%8C%85%E5%90%AB%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%89%80%E6%9C%89%E9%9D%9E%E7%BB%A7%E6%89%BF%E5%8F%AF%E6%9E%9A%E4%B8%BE%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E6%95%B0%E7%BB%84%E3%80%82\",\"Object.preventExtensions()\":\"%E9%98%BB%E6%AD%A2%E5%90%91%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%B7%BB%E5%8A%A0%E6%96%B0%E7%9A%84%E5%B1%9E%E6%80%A7%E3%80%82\",\"Object.seal()\":\"%E9%98%BB%E6%AD%A2%E5%90%91%E6%8C%87%E5%AE%9A%E5%AF%B9%E8%B1%A1%E6%B7%BB%E5%8A%A0%E6%96%B0%E5%B1%9E%E6%80%A7%E6%88%96%E5%88%A0%E9%99%A4%E7%8E%B0%E6%9C%89%E5%B1%9E%E6%80%A7%E3%80%82\"}', '返回值', '如果没有传人value参数，则这个构造函数将返回一个新创建的Object实例。如果传人一个原始value值，则构造函数将创建并返回一个原始值的Number、Boolean或String对象封装。如果不带new操作符，将Object()构造函数像函数那样调用，则它的行为将和使用new操作符时一样。', ''),
('/api_doc/Cookbook/Core', 'Object.constructor', '041', 'Object.constructor', 'Core > Object > constructor', '    所有对象的constructor属性都指向用做当前对象的构造函数的那个函数。例如，如果使用Array()构造函数创建一个数组a，则a.constructor是一个Array：\r\n\r\n        a = new Array(1,2,3); // Create an object\r\n        a.constructor == Array // Evaluates to true\r\n\r\n    constructor属性经常用于检测未知对象的类型。给定一个未知的值，可以使用typeo+操作符来检查它是一个原始值还是一个对象。如果它是一个对象，则可以使用constructor属性来检查对象的类型。例如，下面的函数用于检查给定的值是否是一个数组：\r\n\r\n        function isArray(x) {\r\n            return ((typeof x == \"object\") && (x.constructor == Array));\r\n        }\r\n\r\n    不过，需要注意，这个技术只对核心JavaScript中的内置对象有效，对那些宿主对象（如客户端JavaScript的Window对象等）而言则未必有效。Object.toString()方法提供了另外一种判断未知对象类型的方法。', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Object.constructor_draft', '041', 'Object.constructor', 'Core > Object > constructor', '    所有对象的constructor属性都指向用做当前对象的构造函数的那个函数。例如，如果使用Array()构造函数创建一个数组a，则a.constructor是一个Array：\r\n\r\n        a = new Array(1,2,3); // Create an object\r\n        a.constructor == Array // Evaluates to true\r\n\r\n    constructor属性经常用于检测未知对象的类型。给定一个未知的值，可以使用typeo+操作符来检查它是一个原始值还是一个对象。如果它是一个对象，则可以使用constructor属性来检查对象的类型。例如，下面的函数用于检查给定的值是否是一个数组：\r\n\r\n        function isArray(x) {\r\n            return ((typeof x == \"object\") && (x.constructor == Array));\r\n        }\r\n\r\n    不过，需要注意，这个技术只对核心JavaScript中的内置对象有效，对那些宿主对象（如客户端JavaScript的Window对象等）而言则未必有效。Object.toString()方法提供了另外一种判断未知对象类型的方法。', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Object.create()', '042', 'Object.create()', 'Core > Object > Object.create()', '    使用指定的原型和属性来创建一个对象。\r\n\r\n    语法：\r\n       Object.create(proto)\r\n       Object.create(proto, descriptors)\r\n\r\n    Object．create()创建并返回一个新的以proto为原型的对象。这意味着新对象将继承proto的属性。\r\n    如果指定可选的descriptors参数，则Objects．create0将把它指定的属性添加到新对象中，等同于调用Object.defineProperties()。使用两个参数调用Object.create(p,d)等同于：\r\n\r\n        Object.defineProperties(Object.create(p), d);\r\n\r\n    关于descriptors参数的更多细节可参考Object.defineProperties()，关于属性描述符对象的更多解释可参阅Object．getOwnPropertyDescriptor()。\r\n    注意，Object.create0不是在具体的对象上调用的方法：它是一个全局函数，需要传人一个对象。\r\n\r\n    异常\r\n    TypeError\r\n        如果proto不是对象也不是null，或者指定descriptors但它引发Object.defineProperties()抛出了一个TypeError。', '参数 Object.create(proto[, descriptors])', '{\"proto\":\"%E6%96%B0%E5%88%9B%E5%BB%BA%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%EF%BC%8C%E5%8F%AF%E4%B8%BAnull%E3%80%82\",\"descriptors\":\"%E4%B8%80%E4%B8%AA%E5%8F%AF%E9%80%89%E5%AF%B9%E8%B1%A1%EF%BC%8C%E6%8A%8A%E5%B1%9E%E6%80%A7%E5%90%8D%E6%98%A0%E5%B0%84%E5%88%B0%E5%B1%9E%E6%80%A7%E6%8F%8F%E8%BF%B0%E7%AC%A6%E3%80%82\"}', '', '', '', '', '返回值', '一个新创建的对象，继承自proto，同时拥有descriptors所描述的属性。', '// Create an object that has own properties x and y and inherits property z\r\nvar p = Object.create({z:0}, {\r\n    x: { value: 1, writable: false, enumerable:true, configurable: true},\r\n    y: { value: 2, writable: false, enumerable:true, configurable: true}\r\n});'),
('/api_doc/Cookbook/Core', 'Object.create()_draft', '042', 'Object.create()', 'Core > Object > Object.create()', '    使用指定的原型和属性来创建一个对象。\r\n\r\n    语法：\r\n       Object.create(proto)\r\n       Object.create(proto, descriptors)\r\n\r\n    Object．create()创建并返回一个新的以proto为原型的对象。这意味着新对象将继承proto的属性。\r\n    如果指定可选的descriptors参数，则Objects．create0将把它指定的属性添加到新对象中，等同于调用Object.defineProperties()。使用两个参数调用Object.create(p,d)等同于：\r\n\r\n        Object.defineProperties(Object.create(p), d);\r\n\r\n    关于descriptors参数的更多细节可参考Object.defineProperties()，关于属性描述符对象的更多解释可参阅Object．getOwnPropertyDescriptor()。\r\n    注意，Object.create0不是在具体的对象上调用的方法：它是一个全局函数，需要传人一个对象。\r\n\r\n    异常\r\n    TypeError\r\n        如果proto不是对象也不是null，或者指定descriptors但它引发Object.defineProperties()抛出了一个TypeError。', '参数 Object.create(proto[, descriptors])', '{\"proto\":\"%E6%96%B0%E5%88%9B%E5%BB%BA%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%8E%9F%E5%9E%8B%EF%BC%8C%E5%8F%AF%E4%B8%BAnull%E3%80%82\",\"descriptors\":\"%E4%B8%80%E4%B8%AA%E5%8F%AF%E9%80%89%E5%AF%B9%E8%B1%A1%EF%BC%8C%E6%8A%8A%E5%B1%9E%E6%80%A7%E5%90%8D%E6%98%A0%E5%B0%84%E5%88%B0%E5%B1%9E%E6%80%A7%E6%8F%8F%E8%BF%B0%E7%AC%A6%E3%80%82\"}', '', '', '', '', '返回值', '一个新创建的对象，继承自proto，同时拥有descriptors所描述的属性。', '// Create an object that has own properties x and y and inherits property z\r\nvar p = Object.create({z:0}, {\r\n    x: { value: 1, writable: false, enumerable:true, configurable: true},\r\n    y: { value: 2, writable: false, enumerable:true, configurable: true}\r\n});'),
('/api_doc/Cookbook/Core', 'Object.defineProperties()', '043', 'Object.defineProperties()', 'Core > Object > Object.defineProperties()', '    创建或配置指定对象的一个或多个属性。\r\n\r\n    Object.defineProperties()在对象o上创建或配置由descriptors指定及描述的属性。descriptors中的属性名也就是要在o上创建或配置的属性名，同时指定对应的属性的值。\r\n    Object.defineProperties()的行为非常类似Object.defineProperty()，可参阅这个函数以便了解更多细节。关于描述符对象的更多细节可参阅Object.getOwnPropertyDescriptor()。\r\n\r\n    异常\r\n    TypeError\r\n        如果o不是一个对象，或不能创建或配置某个指定的属性，就抛出该异常。这个函数不是原子性的：它可能在创建或配置几个属性之后，同时还有别的属性未创建或配置时抛出异常。', '参数 Object.defineProperties(o, descriptors)', '{\"o\":\"%E8%A6%81%E5%9C%A8%E5%85%B6%E4%B8%8A%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"descriptors\":\"%E5%B0%86%E5%B1%9E%E6%80%A7%E5%90%8D%E6%98%A0%E5%B0%84%E5%88%B0%E5%B1%9E%E6%80%A7%E6%8F%8F%E8%BF%B0%E7%AC%A6%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '对象o', '// Add read-only properties x and y to a newly-created object\r\nvar p = Object.defineProperties({}, {\r\n    x: { value: 0, writable: false, enumerable:true, configurable: true},\r\n    y: { value: 1, writable: false, enumerable:true, configurable: true}\r\n});'),
('/api_doc/Cookbook/Core', 'Object.defineProperties()_draft', '043', 'Object.defineProperties()', 'Core > Object > Object.defineProperties()', '    创建或配置指定对象的一个或多个属性。\r\n\r\n    Object.defineProperties()在对象o上创建或配置由descriptors指定及描述的属性。descriptors中的属性名也就是要在o上创建或配置的属性名，同时指定对应的属性的值。\r\n    Object.defineProperties()的行为非常类似Object.defineProperty()，可参阅这个函数以便了解更多细节。关于描述符对象的更多细节可参阅Object.getOwnPropertyDescriptor()。\r\n\r\n    异常\r\n    TypeError\r\n        如果o不是一个对象，或不能创建或配置某个指定的属性，就抛出该异常。这个函数不是原子性的：它可能在创建或配置几个属性之后，同时还有别的属性未创建或配置时抛出异常。', '', '', '', '', '', '', '', '', ''),
('/api_doc/Cookbook/Core', 'Object.defineProperty()', '044', 'Object.defineProperty()', 'Core > Object > Object.defineProperty()', '    创建或配置指定对象的某个属性。\r\n\r\n    Object.defineProperty()使用属性描述符desc来创建或配置对象o中名为name的属性。关于属性描述符对象的描述，可参阅Object.getOwnPropertyDescriptor()。\r\n    如果o还不存在名为name的属性，则这个函数将简单地使用desc中指定的属性和值来创建一个新的属性。对于desc中未指定的属性，对应的属性值将设置为false或null。\r\n    如果name为o中一个已经存在的属性名，则Object.defineProperty()将通过改变它的值或属性来配置这个属性。在这种情况下，desc只需要包含要改变的属性，不包含的属性将不会改变。\r\n    注意这不是在具体的对象上调用的方法，它是一个全局函数，必须传人一个对象。\r\n\r\n    异常\r\n    TypeError\r\n        如果o不是一个对象，或者指定属性不能创建（比如o不可扩展）或配置（比如该属性已经存在，并且不可配置）。', '参数 Object.defineProperty(o, name, desc)', '{\"o\":\"%E5%B0%86%E5%9C%A8%E5%85%B6%E4%B8%8A%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"name\":\"%E5%B0%86%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E7%9A%84%E5%B1%9E%E6%80%A7%E7%9A%84%E5%90%8D%E5%AD%97%E3%80%82\",\"desc\":\"%E4%B8%80%E4%B8%AA%E5%B1%9E%E6%80%A7%E6%8F%8F%E8%BF%B0%E7%AC%A6%E5%AF%B9%E8%B1%A1%EF%BC%8C%E6%8F%8F%E8%BF%B0%E8%A6%81%E5%88%9B%E5%BB%BA%E7%9A%84%E6%96%B0%E5%B1%9E%E6%80%A7%E6%88%96%E5%AF%B9%E7%8E%B0%E6%9C%89%E5%B1%9E%E6%80%A7%E7%9A%84%E4%BF%AE%E6%94%B9%E3%80%82\"}', '', '', '', '', '返回值', '对象o。', 'function constant(o, n, v) { // Define a constant o.n with value v\r\n    Object.defineProperty(o, n, { \r\n        value: v, \r\n        writable: false,\r\n        enumerable: true, \r\n        configurable:false\r\n    });\r\n}'),
('/api_doc/Cookbook/Core', 'Object.defineProperty()_draft', '044', 'Object.defineProperty()', 'Core > Object > Object.defineProperty()', '    创建或配置指定对象的某个属性。\r\n\r\n    Object.defineProperty()使用属性描述符desc来创建或配置对象o中名为name的属性。关于属性描述符对象的描述，可参阅Object.getOwnPropertyDescriptor()。\r\n    如果o还不存在名为name的属性，则这个函数将简单地使用desc中指定的属性和值来创建一个新的属性。对于desc中未指定的属性，对应的属性值将设置为false或null。\r\n    如果name为o中一个已经存在的属性名，则Object.defineProperty()将通过改变它的值或属性来配置这个属性。在这种情况下，desc只需要包含要改变的属性，不包含的属性将不会改变。\r\n    注意这不是在具体的对象上调用的方法，它是一个全局函数，必须传人一个对象。\r\n\r\n    异常\r\n    TypeError\r\n        如果o不是一个对象，或者指定属性不能创建（比如o不可扩展）或配置（比如该属性已经存在，并且不可配置）。', '参数 Object.defineProperty(o, name, desc)', '{\"o\":\"%E5%B0%86%E5%9C%A8%E5%85%B6%E4%B8%8A%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"name\":\"%E5%B0%86%E5%88%9B%E5%BB%BA%E6%88%96%E9%85%8D%E7%BD%AE%E7%9A%84%E5%B1%9E%E6%80%A7%E7%9A%84%E5%90%8D%E5%AD%97%E3%80%82\",\"desc\":\"%E4%B8%80%E4%B8%AA%E5%B1%9E%E6%80%A7%E6%8F%8F%E8%BF%B0%E7%AC%A6%E5%AF%B9%E8%B1%A1%EF%BC%8C%E6%8F%8F%E8%BF%B0%E8%A6%81%E5%88%9B%E5%BB%BA%E7%9A%84%E6%96%B0%E5%B1%9E%E6%80%A7%E6%88%96%E5%AF%B9%E7%8E%B0%E6%9C%89%E5%B1%9E%E6%80%A7%E7%9A%84%E4%BF%AE%E6%94%B9%E3%80%82\"}', '', '', '', '', '返回值', '对象o。', 'function constant(o, n, v) { // Define a constant o.n with value v\r\n    Object.defineProperty(o, n, { \r\n        value: v, \r\n        writable: false,\r\n        enumerable: true, \r\n        configurable:false\r\n    });\r\n}'),
('/api_doc/Cookbook/Core', 'Object.freeze()', '045', 'Object.freeze()', 'Core > Object > Object.freeze()', '    将指定对象设置为不可改变。\r\n\r\n    Object.freeze0将o设置为不可扩展(参阅Object.preventExtensions())，同时就像Object.seal()那样，将它的所有自有属性设置为不可配置。除此之外，它也将所有非承的数据属性设置为只读。这意味着不能向o添加新属性，同时已有的属性也不能设置或删除。冻结对象是一个永久性的操作，一旦冻结，就不能解冻。\r\n    注意，Object.freeze0只设置数据属性的可写特性，那些有对应setter函数的属性不会受到影响。还要注意，Object.freeze0不会影响继承属性。\r\n    注意这个方法不可以在具体的对象上调用，它是一个全局函数，必须传人一个对象。', '参数 Object.freeze(o)', '{\"o\":\"%E8%A6%81%E5%86%BB%E7%BB%93%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '现在处于冻结状态的参数对象D。', ''),
('/api_doc/Cookbook/Core', 'Object.freeze()_draft', '045', 'Object.freeze()', 'Core > Object > Object.freeze()', '    将指定对象设置为不可改变。\r\n\r\n    Object.freeze0将o设置为不可扩展(参阅Object.preventExtensions())，同时就像Object.seal()那样，将它的所有自有属性设置为不可配置。除此之外，它也将所有非承的数据属性设置为只读。这意味着不能向o添加新属性，同时已有的属性也不能设置或删除。冻结对象是一个永久性的操作，一旦冻结，就不能解冻。\r\n    注意，Object.freeze0只设置数据属性的可写特性，那些有对应setter函数的属性不会受到影响。还要注意，Object.freeze0不会影响继承属性。\r\n    注意这个方法不可以在具体的对象上调用，它是一个全局函数，必须传人一个对象。', '参数 Object.freeze(o)', '{\"o\":\"%E8%A6%81%E5%86%BB%E7%BB%93%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '现在处于冻结状态的参数对象D。', ''),
('/api_doc/Cookbook/Core', 'Object.getOwnPropertyDescriptor()', '046', 'Object.getOwnPropertyDescriptor()', 'Core > Object > Object.getOwnPropertyDescriptor()', '    Object.getOwnPrepertyDescriptor()返回指定对象指定属性的一个属性描述符。属性描述符是一个对象，描述该属性的特性和值。注意，这个方法不可以在具体的对象上调用，它是一个全局函数，必须传人一个对象。\r\n    属性描述符\r\n        属性描述符是一个普通的JavaScript对象，描述某个属性的特性（有时也包括值）。有两种JavaScript属性。数据属性有一个值以及三个性质：可枚举性(enumerable)、可写性(writable)以及可配置性(configurable)。访问器属性(accessor property)有一个getter和／或setter方法，以及可枚举性和可配置性。\r\n        数据属性的描述符类似这样：\r\n        {\r\n            value: /* any JavaScript value */,\r\n            writable: /* true or false */,\r\n            enumerable: /* true or false */,\r\n            configurable: /* true or false */\r\n        }\r\n        访问器属性的描述符类似这样：\r\n        {\r\n            get: /* function or undefined: replaces the property value */,\r\n            set: /* function or undefined: replaces the writable attribute */,\r\n            enumerable: /* true or false */,\r\n            configurable: /* true or false */\r\n        }', '参数 Object.getOwnPropertyDescriptor(o, name)', '{\"o\":\"%E5%BE%85%E6%9F%A5%E8%AF%A2%E5%85%B6%E5%B1%9E%E6%80%A7%E7%89%B9%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"name\":\"%E5%BE%85%E6%9F%A5%E8%AF%A2%E7%9A%84%E5%B1%9E%E6%80%A7%E5%90%8D%EF%BC%88%E6%88%96%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E7%B4%A2%E5%BC%95%EF%BC%89%E3%80%82\"}', '', '', '', '', '返回值', '指定对象指定属性的一个属性描述符对象，如果不存在指定属性则返回undefined。', ''),
('/api_doc/Cookbook/Core', 'Object.getOwnPropertyDescriptor()_draft', '046', 'Object.getOwnPropertyDescriptor()', 'Core > Object > Object.getOwnPropertyDescriptor()', '    Object.getOwnPrepertyDescriptor()返回指定对象指定属性的一个属性描述符。属性描述符是一个对象，描述该属性的特性和值。注意，这个方法不可以在具体的对象上调用，它是一个全局函数，必须传人一个对象。\r\n    属性描述符\r\n        属性描述符是一个普通的JavaScript对象，描述某个属性的特性（有时也包括值）。有两种JavaScript属性。数据属性有一个值以及三个性质：可枚举性(enumerable)、可写性(writable)以及可配置性(configurable)。访问器属性(accessor property)有一个getter和／或setter方法，以及可枚举性和可配置性。\r\n        数据属性的描述符类似这样：\r\n        {\r\n            value: /* any JavaScript value */,\r\n            writable: /* true or false */,\r\n            enumerable: /* true or false */,\r\n            configurable: /* true or false */\r\n        }\r\n        访问器属性的描述符类似这样：\r\n        {\r\n            get: /* function or undefined: replaces the property value */,\r\n            set: /* function or undefined: replaces the writable attribute */,\r\n            enumerable: /* true or false */,\r\n            configurable: /* true or false */\r\n        }', '参数 Object.getOwnPropertyDescriptor(o, name)', '{\"o\":\"%E5%BE%85%E6%9F%A5%E8%AF%A2%E5%85%B6%E5%B1%9E%E6%80%A7%E7%89%B9%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\",\"name\":\"%E5%BE%85%E6%9F%A5%E8%AF%A2%E7%9A%84%E5%B1%9E%E6%80%A7%E5%90%8D%EF%BC%88%E6%88%96%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E7%B4%A2%E5%BC%95%EF%BC%89%E3%80%82\"}', '', '', '', '', '返回值', '指定对象指定属性的一个属性描述符对象，如果不存在指定属性则返回undefined。', ''),
('/api_doc/Cookbook/Core', 'Object.getOwnPropertyNames()', '047', 'Object.getOwnPropertyNames()', 'Core > Object > Object.getOwnPropertyNames()', '    返回一个包含指定对象的所有非继承属性名的数组，包括不可枚举属性。\r\n    Object.getOwnPropertyNames()返回一个包含D的所有非继承属性的名字的数组，包括那些不可枚举的属性。关于只返回可枚举属性的名字的方法可参考Objects．keys()。\r\n    注意，这个方法不可在对象上调用，它是一个全局函数，必须传入一个对象。', '参数 Object.getOwnPropertyNames(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '一个包含o的所有非继承属性的名字的数组，包括那些不可枚举的属性。', 'Object.getOwnPropertyNames([]) // => [\"length\"]: \"length\" is non-enumerable'),
('/api_doc/Cookbook/Core', 'Object.getOwnPropertyNames()_draft', '047', 'Object.getOwnPropertyNames()', 'Core > Object > Object.getOwnPropertyNames()', '    返回一个包含指定对象的所有非继承属性名的数组，包括不可枚举属性。\r\n    Object.getOwnPropertyNames()返回一个包含D的所有非继承属性的名字的数组，包括那些不可枚举的属性。关于只返回可枚举属性的名字的方法可参考Objects．keys()。\r\n    注意，这个方法不可在对象上调用，它是一个全局函数，必须传入一个对象。', '参数 Object.getOwnPropertyNames(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '一个包含o的所有非继承属性的名字的数组，包括那些不可枚举的属性。', 'Object.getOwnPropertyNames([]) // => [\"length\"]: \"length\" is non-enumerable'),
('/api_doc/Cookbook/Core', 'Object.getPrototypeOf()', '048', 'Object.getPrototypeOf()', 'Core > Object > Object.getPrototypeOf()', '   返回一个对象的原型。\r\n\r\n    Object。getPrototypeOf()返回它的参数的原型。注意这是一个全局函数，必须传入一个对象。它不是在对象上调用的方法。', '参数 Object.getPrototypeOf(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', 'o的原型对象。', 'var p = {}; // An ordinary object\r\nObject.getPrototypeOf(p) // => Object.prototype\r\nvar o = Object.create(p) // An object that inherits from p\r\nObject.getPrototypeOf(o) // => p'),
('/api_doc/Cookbook/Core', 'Object.getPrototypeOf()_draft', '048', 'Object.getPrototypeOf()', 'Core > Object > Object.getPrototypeOf()', '   返回一个对象的原型。\r\n\r\n    Object。getPrototypeOf()返回它的参数的原型。注意这是一个全局函数，必须传入一个对象。它不是在对象上调用的方法。', '参数 Object.getPrototypeOf(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', 'o的原型对象。', 'var p = {}; // An ordinary object\r\nObject.getPrototypeOf(p) // => Object.prototype\r\nvar o = Object.create(p) // An object that inherits from p\r\nObject.getPrototypeOf(o) // => p'),
('/api_doc/Cookbook/Core', 'Object.hasOwnProperty()', '055', 'Object.hasOwnProperty()', 'Core > Object > hasOwnProperty()', '    检查一个属性是否是继承的。\r\n\r\n    JavaScript对象可以有自己的属性，也可以从它们的原型对象那儿继承属性。hasOwnProperty()方法提供一个识别继承属性和非继承的本地属性的方法。', '参数 object.hasOwnProperty(propname)', '{\"propname\":\"%E5%8C%85%E5%90%AB%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\"}', '', '', '', '', '返回值', '如果对象有一个指定名字的非继承的属性则返回true；如果该对象没有指定名字的属性，或者这个属性是从它的原型对象继承而来的，则返回false。', 'var o = new Object(); // Create an object\r\no.x = 3.14; // Define a noninherited local property\r\no.hasOwnProperty(\"x\"); // Returns true: x is a local property of o\r\no.hasOwnProperty(\"y\"); // Returns false: o doesn\'t have a property y\r\no.hasOwnProperty(\"toString\"); // Returns false: toString property is inherited'),
('/api_doc/Cookbook/Core', 'Object.hasOwnProperty()_draft', '055', 'Object.hasOwnProperty()', 'Core > Object > hasOwnProperty()', '    检查一个属性是否是继承的。\r\n\r\n    JavaScript对象可以有自己的属性，也可以从它们的原型对象那儿继承属性。hasOwnProperty()方法提供一个识别继承属性和非继承的本地属性的方法。', '参数 object.hasOwnProperty(propname)', '{\"propname\":\"%E5%8C%85%E5%90%AB%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\"}', '', '', '', '', '返回值', '如果对象有一个指定名字的非继承的属性则返回true；如果该对象没有指定名字的属性，或者这个属性是从它的原型对象继承而来的，则返回false。', 'var o = new Object(); // Create an object\r\no.x = 3.14; // Define a noninherited local property\r\no.hasOwnProperty(\"x\"); // Returns true: x is a local property of o\r\no.hasOwnProperty(\"y\"); // Returns false: o doesn\'t have a property y\r\no.hasOwnProperty(\"toString\"); // Returns false: toString property is inherited'),
('/api_doc/Cookbook/Core', 'Object.isExtensible()', '049', 'Object.isExtensible()', 'Core > Object > Object.isExtensible()', '    检查当前对象是否能添加到新的属性中。\r\n\r\n    如果可以向一个对象添加新的属性，则称它为可扩展的。所有对象在创建后都是可扩展的，直到它们被传人Object.preventExtensions()、Object.seal()或Object.freeze()。\r\n    注意这不是对象的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isExtensible(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%9F%A5%E5%8F%AF%E6%89%A9%E5%B1%95%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果可以向该对象添加新属性则返回true;否则返回false。', 'var o = {}; // Start with a newly-created object\r\nObject.isExtensible(o) // => true: it is extendable\r\nObject.preventExtensions(o); // Make it non-extendable\r\nObject.isExtensible(o) // => false: now it is not extendable'),
('/api_doc/Cookbook/Core', 'Object.isExtensible()_draft', '049', 'Object.isExtensible()', 'Core > Object > Object.isExtensible()', '    检查当前对象是否能添加到新的属性中。\r\n\r\n    如果可以向一个对象添加新的属性，则称它为可扩展的。所有对象在创建后都是可扩展的，直到它们被传人Object.preventExtensions()、Object.seal()或Object.freeze()。\r\n    注意这不是对象的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isExtensible(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%9F%A5%E5%8F%AF%E6%89%A9%E5%B1%95%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果可以向该对象添加新属性则返回true;否则返回false。', 'var o = {}; // Start with a newly-created object\r\nObject.isExtensible(o) // => true: it is extendable\r\nObject.preventExtensions(o); // Make it non-extendable\r\nObject.isExtensible(o) // => false: now it is not extendable'),
('/api_doc/Cookbook/Core', 'Object.isFrozen()', '050', 'Object.isFrozen()', 'Core > Object > Object.isFrozen()', '    检查当前对象是否已冻结。\r\n\r\n    如果一个对象的所有非继承属性（除了那些带setter方法的）都为只读，或者它是封闭的(sealed)，则它处于冻结状态。如果可以向一个对象添加新的（非继承的）属性，并且不可删除现有的（非继承的）属性，则称它为封闭的。Object.isFrozen()检测它的参数是否为冻结状态。对象一旦冻结就不能再解冻。\r\n    冻结一个对象的常用方法为将它传给Object.freeze()。也可以这样冻结一个对象：将它传给Object.preventExtensions()，然后用Object.defineProperty()来将它所有的属性设置为只读并且不可删除的。\r\n    注意这不是在对象上调用的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isFrozen(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%B5%8B%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果o已冻结并不改变则为true;否则为false。', ''),
('/api_doc/Cookbook/Core', 'Object.isFrozen()_draft', '050', 'Object.isFrozen()', 'Core > Object > Object.isFrozen()', '    检查当前对象是否已冻结。\r\n\r\n    如果一个对象的所有非继承属性（除了那些带setter方法的）都为只读，或者它是封闭的(sealed)，则它处于冻结状态。如果可以向一个对象添加新的（非继承的）属性，并且不可删除现有的（非继承的）属性，则称它为封闭的。Object.isFrozen()检测它的参数是否为冻结状态。对象一旦冻结就不能再解冻。\r\n    冻结一个对象的常用方法为将它传给Object.freeze()。也可以这样冻结一个对象：将它传给Object.preventExtensions()，然后用Object.defineProperty()来将它所有的属性设置为只读并且不可删除的。\r\n    注意这不是在对象上调用的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isFrozen(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%B5%8B%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果o已冻结并不改变则为true;否则为false。', ''),
('/api_doc/Cookbook/Core', 'Object.isPrototypeOf()', '056', 'Object .isPrototypeOf()', 'Core > Object > isPrototypeOf()', '    判断当前对象是否为另一个对象的原型。\r\n\r\n    JavaScript对象从它们的原型对象中继承属性。对象的原型通过prototype属性指向创建并初始化该对象的构造函数。isPrototypeOf()方法提供一种判断某个对象是否为另一个对象的原型的方法。这个技术可用于判断对象的类。', '参数 object.isPrototypeOf(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果object是o的原型则返回true；如果o不是一个对象，或object不是o的原型则返回false。', 'var o = new Object(); // Create an object\r\nObject.prototype.isPrototypeOf(o) // true: o is an object\r\nFunction.prototype.isPrototypeOf(o.toString); // true: toString is a function\r\nArray.prototype.isPrototypeOf([1,2,3]); // true: [1,2,3] is an array\r\n// Here is a way to perform a similar test\r\n(o.constructor == Object); // true: o was created with Object() constructor\r\n(o.toString.constructor == Function); // true: o.toString is a function\r\n// Prototype objects themselves have prototypes. The following call\r\n// returns true, showing that function objects inherit properties\r\n// from Function.prototype and also from Object.prototype.\r\nObject.prototype.isPrototypeOf(Function.prototype);'),
('/api_doc/Cookbook/Core', 'Object.isPrototypeOf()_draft', '056', 'Object .isPrototypeOf()', 'Core > Object > isPrototypeOf()', '    判断当前对象是否为另一个对象的原型。\r\n\r\n    JavaScript对象从它们的原型对象中继承属性。对象的原型通过prototype属性指向创建并初始化该对象的构造函数。isPrototypeOf()方法提供一种判断某个对象是否为另一个对象的原型的方法。这个技术可用于判断对象的类。', '参数 object.isPrototypeOf(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果object是o的原型则返回true；如果o不是一个对象，或object不是o的原型则返回false。', 'var o = new Object(); // Create an object\r\nObject.prototype.isPrototypeOf(o) // true: o is an object\r\nFunction.prototype.isPrototypeOf(o.toString); // true: toString is a function\r\nArray.prototype.isPrototypeOf([1,2,3]); // true: [1,2,3] is an array\r\n// Here is a way to perform a similar test\r\n(o.constructor == Object); // true: o was created with Object() constructor\r\n(o.toString.constructor == Function); // true: o.toString is a function\r\n// Prototype objects themselves have prototypes. The following call\r\n// returns true, showing that function objects inherit properties\r\n// from Function.prototype and also from Object.prototype.\r\nObject.prototype.isPrototypeOf(Function.prototype);'),
('/api_doc/Cookbook/Core', 'Object.isSealed()', '051', 'Object.isSealed()', 'Core > Object > Object.isSealed()', '    判断一个对象的属性是否可添加或删除。\r\n\r\n    如果不可以向一个对象添加新的（非继承的）属性，并且现有的（非继承的）属性不可删除，则称它为封闭的。Object.isSealed()检测它的参数是否为封闭对象。对象一旦封闭，将没有办法解封。封闭一个对象的常用方法是将它传递给Object.seal()或Object.freeze()。也可以这样封闭一个对象：将它传人Object.preventExtensions()，再使用Object.defineProperty()来将将它的所有属性设置为不可删除的。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isSealed(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%B5%8B%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果o是封闭的则为true;否则为false。', ''),
('/api_doc/Cookbook/Core', 'Object.isSealed()_draft', '051', 'Object.isSealed()', 'Core > Object > Object.isSealed()', '    判断一个对象的属性是否可添加或删除。\r\n\r\n    如果不可以向一个对象添加新的（非继承的）属性，并且现有的（非继承的）属性不可删除，则称它为封闭的。Object.isSealed()检测它的参数是否为封闭对象。对象一旦封闭，将没有办法解封。封闭一个对象的常用方法是将它传递给Object.seal()或Object.freeze()。也可以这样封闭一个对象：将它传人Object.preventExtensions()，再使用Object.defineProperty()来将将它的所有属性设置为不可删除的。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传人一个对象。', '参数 Object.isSealed(o)', '{\"o\":\"%E5%BE%85%E6%A3%80%E6%B5%8B%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '如果o是封闭的则为true;否则为false。', ''),
('/api_doc/Cookbook/Core', 'Object.keys()', '052', 'Object.keys()', 'Core > Object > Object.keys()', '    返回自有的可枚举属性名。\r\n\r\n    Object.keys()返回指定对象D的属性名组成的数组。这个数组只包含那些可枚举并且直接定义在D上的属性的名字，不包含继承的属性。(关于取得不可枚举的属性名的方法可参阅Object.getOwnPropertyNames())返回数组中的属性名的顺序即它们通过for/in循环枚举时的顺序。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.keys(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '一个包含o的所有可枚举自有（非继承）属性的名字的数组。', 'Object.keys({x:1, y:2}) // => [\"x\", \"y\"]'),
('/api_doc/Cookbook/Core', 'Object.keys()_draft', '052', 'Object.keys()', 'Core > Object > Object.keys()', '    返回自有的可枚举属性名。\r\n\r\n    Object.keys()返回指定对象D的属性名组成的数组。这个数组只包含那些可枚举并且直接定义在D上的属性的名字，不包含继承的属性。(关于取得不可枚举的属性名的方法可参阅Object.getOwnPropertyNames())返回数组中的属性名的顺序即它们通过for/in循环枚举时的顺序。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.keys(o)', '{\"o\":\"%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '一个包含o的所有可枚举自有（非继承）属性的名字的数组。', 'Object.keys({x:1, y:2}) // => [\"x\", \"y\"]'),
('/api_doc/Cookbook/Core', 'Object.preventExtensions()', '053', 'Object.preventExtensions()', 'Core > Object > Object.preventExtensions()', '    禁止在一个对象上添加新的属性。\r\n\r\n    Object.preventExtensions()将o的可扩展性设置为false，之后将不能向它添加新的属性。这是一个永久性的改变：一旦一个对象设置为不可扩展的，它就再也不能改为可扩展的。\r\n    注意Object.preventExtensions()不会影响原型链，不可扩展的对象仍然可以获得新的继承属性。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.preventExtensions(o)', '{\"o\":\"%E5%BE%85%E8%AE%BE%E7%BD%AE%E5%8F%AF%E6%89%A9%E5%B1%95%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '传入的参数对象o。', ''),
('/api_doc/Cookbook/Core', 'Object.preventExtensions()_draft', '053', 'Object.preventExtensions()', 'Core > Object > Object.preventExtensions()', '    禁止在一个对象上添加新的属性。\r\n\r\n    Object.preventExtensions()将o的可扩展性设置为false，之后将不能向它添加新的属性。这是一个永久性的改变：一旦一个对象设置为不可扩展的，它就再也不能改为可扩展的。\r\n    注意Object.preventExtensions()不会影响原型链，不可扩展的对象仍然可以获得新的继承属性。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.preventExtensions(o)', '{\"o\":\"%E5%BE%85%E8%AE%BE%E7%BD%AE%E5%8F%AF%E6%89%A9%E5%B1%95%E6%80%A7%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '传入的参数对象o。', ''),
('/api_doc/Cookbook/Core', 'Object.propertyIsEnumerable()', '057', 'Object .propertyIsEnumerable()', 'Core > Object > propertyIsEnumerable()', '    检测某个属性是否在for/in循环中可见。\r\n\r\n    for/in语句遍历给定对象的可枚举属性。对象的属性不全是可枚举的：那些由JavaScript代码添加到对象中的属性是可枚举的，但那些内置对象的预定义的属性（如方法）通常不可枚举。propertyIsEnumerable()方法提供了一个区分可枚举与不可枚举属性的方法。不过需要注意，ECMAScript标准规定propertyIsEnumerable()不检查原型链，也就是说，这个方法只适用于对象的本地属性，除此之外，没有可用于测试继承属性的可枚举性的方法。', '参数 object.propertyIsEnumerable(propname)', '{\"propname\":\"%E5%8C%85%E5%90%AB%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%8C%87%E5%AE%9A%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E4%B8%80%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\"}', '', '', '', '', '返回值', '如果对象有一个名为propname的非继承属性，并且该属性可枚举，则返回true，这意味着这个属性可以通过该对象的for/in循环枚举。', 'var o = new Object(); // Create an object\r\no.x = 3.14; // Define a property\r\no.propertyIsEnumerable(\"x\"); // true: property x is local and enumerable\r\no.propertyIsEnumerable(\"y\"); // false: o doesn\'t have a property y\r\no.propertyIsEnumerable(\"toString\"); // false: toString property is inherited\r\nObject.prototype.propertyIsEnumerable(\"toString\"); // false: nonenumerable'),
('/api_doc/Cookbook/Core', 'Object.propertyIsEnumerable()_draft', '057', 'Object .propertyIsEnumerable()', 'Core > Object > propertyIsEnumerable()', '    检测某个属性是否在for/in循环中可见。\r\n\r\n    for/in语句遍历给定对象的可枚举属性。对象的属性不全是可枚举的：那些由JavaScript代码添加到对象中的属性是可枚举的，但那些内置对象的预定义的属性（如方法）通常不可枚举。propertyIsEnumerable()方法提供了一个区分可枚举与不可枚举属性的方法。不过需要注意，ECMAScript标准规定propertyIsEnumerable()不检查原型链，也就是说，这个方法只适用于对象的本地属性，除此之外，没有可用于测试继承属性的可枚举性的方法。', '参数 object.propertyIsEnumerable(propname)', '{\"propname\":\"%E5%8C%85%E5%90%AB%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%8C%87%E5%AE%9A%E5%B1%9E%E6%80%A7%E5%90%8D%E7%9A%84%E4%B8%80%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82\"}', '', '', '', '', '返回值', '如果对象有一个名为propname的非继承属性，并且该属性可枚举，则返回true，这意味着这个属性可以通过该对象的for/in循环枚举。', 'var o = new Object(); // Create an object\r\no.x = 3.14; // Define a property\r\no.propertyIsEnumerable(\"x\"); // true: property x is local and enumerable\r\no.propertyIsEnumerable(\"y\"); // false: o doesn\'t have a property y\r\no.propertyIsEnumerable(\"toString\"); // false: toString property is inherited\r\nObject.prototype.propertyIsEnumerable(\"toString\"); // false: nonenumerable'),
('/api_doc/Cookbook/Core', 'Object.seal()', '054', 'Object.seal()', 'Core > Object > Object.seal()', '    阻止添加或删除对象的属性。\r\n\r\n    Object.seal()将o设置为不可扩展(参阅Object.preventExtensions())，同时将它的所有自有属性设置为不可配置的。它的效果为阻止添加新的属性以及阻止删除现有属性。封闭一个对象是永久性的：对象一旦封闭，就不再能解封。\r\n    注意，Object.seal()不仅将属性设置为只读的，这是Object．freeze()的功能。还要注意，Object.seal()不会影响继承属性。如果一个封闭对象的原型链中有一个非封闭对象，那么还可以添加或删除对应的继承属性。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.seal(o)', '{\"o\":\"%E5%BE%85%E5%B0%81%E9%97%AD%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '现在处于封闭状态的参数对象o。', ''),
('/api_doc/Cookbook/Core', 'Object.seal()_draft', '054', 'Object.seal()', 'Core > Object > Object.seal()', '    阻止添加或删除对象的属性。\r\n\r\n    Object.seal()将o设置为不可扩展(参阅Object.preventExtensions())，同时将它的所有自有属性设置为不可配置的。它的效果为阻止添加新的属性以及阻止删除现有属性。封闭一个对象是永久性的：对象一旦封闭，就不再能解封。\r\n    注意，Object.seal()不仅将属性设置为只读的，这是Object．freeze()的功能。还要注意，Object.seal()不会影响继承属性。如果一个封闭对象的原型链中有一个非封闭对象，那么还可以添加或删除对应的继承属性。\r\n    注意这不是在一个对象上调用的方法，它是一个全局函数，必须传入一个对象。', '参数 Object.seal(o)', '{\"o\":\"%E5%BE%85%E5%B0%81%E9%97%AD%E7%9A%84%E5%AF%B9%E8%B1%A1%E3%80%82\"}', '', '', '', '', '返回值', '现在处于封闭状态的参数对象o。', ''),
('/api_doc/Cookbook/Core', 'Object.toLocaleString()', '058', 'Object .toLocaleString()', 'Core > Object > toLocaleString()', '    返回对象的本地化的字符串表示。\r\n\r\n    这个方法用于返回一个表示当前对象的字符串，使用合适的本地化格式。Object类提供的默认的toLocaleString()方法只是简单地调用toString()方法，并返回后者返回的非本地化的字符串。不过要注意，其他类(包括Array、Date以及Number)都各自定义自己的这个方法的版本，用于执行本地化字符串转换。定义自己的类时，可能也需要覆盖这个方法。', '', '', '', '', '', '', '返回值', '一个表示该对象的字符串。', ''),
('/api_doc/Cookbook/Core', 'Object.toLocaleString()_draft', '058', 'Object .toLocaleString()', 'Core > Object > toLocaleString()', '    返回对象的本地化的字符串表示。\r\n\r\n    这个方法用于返回一个表示当前对象的字符串，使用合适的本地化格式。Object类提供的默认的toLocaleString()方法只是简单地调用toString()方法，并返回后者返回的非本地化的字符串。不过要注意，其他类(包括Array、Date以及Number)都各自定义自己的这个方法的版本，用于执行本地化字符串转换。定义自己的类时，可能也需要覆盖这个方法。', '', '', '', '', '', '', '返回值', '一个表示该对象的字符串。', ''),
('/api_doc/Cookbook/Core', 'Object.toString()', '059', 'Object.toString()', 'Core > Object > toString()', '    定义一个对象的字符串表示形式。\r\n\r\n    在JavaScript程序中一般不会经常显式地调用toString()方法。一般情况下，在对象中定义这个方法，系统会在需要时自动调用它以便将该对象转为字符串。\r\n    当对象在一个字符串上下文中使用时，JavaScript系统会调用相应的toString()方法来将该对象转为字符串。例如，把一个对象传人期望参数为字符串的函数时，这个对象会转为字符串。\r\n\r\n        alert(my_object);\r\n\r\n    类似地，当使用“+”操作符将对象与字符串连接时，对象也会转化为字符串。\r\n\r\n        var msg = \"My object is:\" + my_object;\r\n\r\n    调用toString()方法时没有参数，返回值应该是一个字符串。为了便于使用，返回的字符串应当以某种形式与调用这个方法的对象的值相关。\r\n    在JavaScript中定义自定义类时，为这个类定义一个toString()方法是一个不错的实践。如果没有定义这个方法，则对象会从Object类继承默认的toString()方法。默认方法返回的字符串格式形如：\r\n\r\n        [objectclass]\r\n\r\n    其中class是该对象的类：值为“Object”、“String”、“Number”、“Function”、“Window”、“Document”等。有时候可以用默认的toString()方法的这个行为来判断未知对象的类型或类。不过，由于大多数对象都有自定义版本的toString()，因此一般需要在对象上显式地调用Object.toString()方法，类似这样：\r\n\r\n        Object.prototype.toString.apply(o);\r\n\r\n    注意，这个判断未知对象的技术只适用于内置对象。自定义的对象类有一个“Object”类，在这种情况下，可以使用Object．constructor属性来获得关于这个对象的更多信息。\r\n    在调试JavaScript程序时，toString()方法可能会非常有用，可以用它输出对象并查看它们的值。因此，为所创建的每个对象定义一个toString()方法是个不错的主意。\r\n    虽然toString()方法通常由系统自动调用，但有时也需要手动调用它们。比如，有时需要将某个对象显式转化为字符串，但JavaScript没有自动做这个转换时：\r\n\r\n        y = Math.sqrt(x); // Compute a number\r\n        ystr = y.toString(); // Convert it to a string\r\n\r\n    注意，在这个例子中，数字有一个可用于强制转换的内置toString()方法。\r\n    其他情况下，即使在JavaScript会自动转换的上下文中，也可以选择使用toString()。显式地使用toString0有助于使代码更加清晰：\r\n\r\n        alert(my_obj.toString());', '', '', '', '', '', '', '返回值', '一个表示该对象的字符串。', ''),
('/api_doc/Cookbook/Core', 'Object.toString()_draft', '059', 'Object.toString()', 'Core > Object > toString()', '    定义一个对象的字符串表示形式。\r\n\r\n    在JavaScript程序中一般不会经常显式地调用toString()方法。一般情况下，在对象中定义这个方法，系统会在需要时自动调用它以便将该对象转为字符串。\r\n    当对象在一个字符串上下文中使用时，JavaScript系统会调用相应的toString()方法来将该对象转为字符串。例如，把一个对象传人期望参数为字符串的函数时，这个对象会转为字符串。\r\n\r\n        alert(my_object);\r\n\r\n    类似地，当使用“+”操作符将对象与字符串连接时，对象也会转化为字符串。\r\n\r\n        var msg = \"My object is:\" + my_object;\r\n\r\n    调用toString()方法时没有参数，返回值应该是一个字符串。为了便于使用，返回的字符串应当以某种形式与调用这个方法的对象的值相关。\r\n    在JavaScript中定义自定义类时，为这个类定义一个toString()方法是一个不错的实践。如果没有定义这个方法，则对象会从Object类继承默认的toString()方法。默认方法返回的字符串格式形如：\r\n\r\n        [objectclass]\r\n\r\n    其中class是该对象的类：值为“Object”、“String”、“Number”、“Function”、“Window”、“Document”等。有时候可以用默认的toString()方法的这个行为来判断未知对象的类型或类。不过，由于大多数对象都有自定义版本的toString()，因此一般需要在对象上显式地调用Object.toString()方法，类似这样：\r\n\r\n        Object.prototype.toString.apply(o);\r\n\r\n    注意，这个判断未知对象的技术只适用于内置对象。自定义的对象类有一个“Object”类，在这种情况下，可以使用Object．constructor属性来获得关于这个对象的更多信息。\r\n    在调试JavaScript程序时，toString()方法可能会非常有用，可以用它输出对象并查看它们的值。因此，为所创建的每个对象定义一个toString()方法是个不错的主意。\r\n    虽然toString()方法通常由系统自动调用，但有时也需要手动调用它们。比如，有时需要将某个对象显式转化为字符串，但JavaScript没有自动做这个转换时：\r\n\r\n        y = Math.sqrt(x); // Compute a number\r\n        ystr = y.toString(); // Convert it to a string\r\n\r\n    注意，在这个例子中，数字有一个可用于强制转换的内置toString()方法。\r\n    其他情况下，即使在JavaScript会自动转换的上下文中，也可以选择使用toString()。显式地使用toString0有助于使代码更加清晰：\r\n\r\n        alert(my_obj.toString());', '', '', '', '', '', '', '返回值', '一个表示该对象的字符串。', ''),
('/api_doc/Cookbook/Core', 'Object.valueOf()', '060', 'Object.valueOf()', 'Core > Object > valueOf()', '    对象的valueOf()方法返回与该对象关联的原始值，如果存在这样一个值的话。类型为Object的对象没有原始值，这个方法只是简单地返回该对象本身。\r\n    不过，对类型为Number的对象而言，valueOf()将返回该对象表示的原始数字值。类似地，Boolean对象会返回一个关联的原始布尔值，String对象则返回一个关联的字符串。\r\n    valueOf()方法很少需要手动调用，在需要原始值时，JavaScript会自动调用这个方法。事实上，由于有对valueOf()方法的自动调用，甚至很难区分原始值和它们的关联对象。例如，虽然typeof操作符能告诉你字符串和String对象之间的不同，但在实际应用的JavaScript代码中两者完全可以等价。\r\n    Number、Boolean以及String对象的valueOf()方法将这些包装对象转化为它们所表示的原始值。传人数字、布尔值、字符串到Object()构造函数时则进行相反的操作：它将原始值包装到一个合适的对象包装中。在绝大多数情况下，JavaScript会自动处理这种原始值到对象的转换，所以很少需要这样调用Object()构造函数。\r\n    在有些情况下，你可能恕为自己的对象自定义一个valueOf()方法。例如，你可能需要定义一个JavaScript对象来表示复数（一个实数加上一个虚数）。作为这个对象类型的一部分，你可能需要定义执行加法、乘法等的方法（参阅例9-3）。但你可能也想丢弃复数的虚部以便像普通实数一样处理它们。为了实现这些功能，你可能需要写类似下面的代码：\r\n\r\n    Complex.prototype.valueOf = new Function(\"return this.real\");\r\n\r\n为Complex对象类型定义这个valueOf()方法后，就可以，例如，将一个复数对象传人Math.sqrt()，以便计算这个复数的实部的平方根。', '', '', '', '', '', '', '返回值', '与指定对象关联的原始值，如果存在这样一个值的话。如果没有与该对象关联的值，则返回对象本身。', ''),
('/api_doc/Cookbook/Core', 'Object.valueOf()_draft', '060', 'Object.valueOf()', 'Core > Object > valueOf()', '    对象的valueOf()方法返回与该对象关联的原始值，如果存在这样一个值的话。类型为Object的对象没有原始值，这个方法只是简单地返回该对象本身。\r\n    不过，对类型为Number的对象而言，valueOf()将返回该对象表示的原始数字值。类似地，Boolean对象会返回一个关联的原始布尔值，String对象则返回一个关联的字符串。\r\n    valueOf()方法很少需要手动调用，在需要原始值时，JavaScript会自动调用这个方法。事实上，由于有对valueOf()方法的自动调用，甚至很难区分原始值和它们的关联对象。例如，虽然typeof操作符能告诉你字符串和String对象之间的不同，但在实际应用的JavaScript代码中两者完全可以等价。\r\n    Number、Boolean以及String对象的valueOf()方法将这些包装对象转化为它们所表示的原始值。传人数字、布尔值、字符串到Object()构造函数时则进行相反的操作：它将原始值包装到一个合适的对象包装中。在绝大多数情况下，JavaScript会自动处理这种原始值到对象的转换，所以很少需要这样调用Object()构造函数。\r\n    在有些情况下，你可能恕为自己的对象自定义一个valueOf()方法。例如，你可能需要定义一个JavaScript对象来表示复数（一个实数加上一个虚数）。作为这个对象类型的一部分，你可能需要定义执行加法、乘法等的方法（参阅例9-3）。但你可能也想丢弃复数的虚部以便像普通实数一样处理它们。为了实现这些功能，你可能需要写类似下面的代码：\r\n\r\n    Complex.prototype.valueOf = new Function(\"return this.real\");\r\n\r\n为Complex对象类型定义这个valueOf()方法后，就可以，例如，将一个复数对象传人Math.sqrt()，以便计算这个复数的实部的平方根。', '', '', '', '', '', '', '返回值', '与指定对象关联的原始值，如果存在这样一个值的话。如果没有与该对象关联的值，则返回对象本身。', '');


